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_DsGetNT4ChangeLogRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5158 {
5159         if (ndr_flags & NDR_SCALARS) {
5160                 NDR_CHECK(ndr_push_align(ndr, 5));
5161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
5162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
5163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
5164                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
5165                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5166         }
5167         if (ndr_flags & NDR_BUFFERS) {
5168                 if (r->data) {
5169                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
5170                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
5171                 }
5172         }
5173         return NDR_ERR_SUCCESS;
5174 }
5175
5176 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5177 {
5178         uint32_t _ptr_data;
5179         TALLOC_CTX *_mem_save_data_0;
5180         if (ndr_flags & NDR_SCALARS) {
5181                 NDR_CHECK(ndr_pull_align(ndr, 5));
5182                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
5183                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
5184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
5185                 if (r->length > 0x00A00000) {
5186                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5187                 }
5188                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
5189                 if (_ptr_data) {
5190                         NDR_PULL_ALLOC(ndr, r->data);
5191                 } else {
5192                         r->data = NULL;
5193                 }
5194                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5195         }
5196         if (ndr_flags & NDR_BUFFERS) {
5197                 if (r->data) {
5198                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5199                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
5200                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
5201                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
5202                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
5203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
5204                 }
5205                 if (r->data) {
5206                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
5207                 }
5208         }
5209         return NDR_ERR_SUCCESS;
5210 }
5211
5212 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5213 {
5214         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogRequest1");
5215         ndr->depth++;
5216         ndr_print_uint32(ndr, "unknown1", r->unknown1);
5217         ndr_print_uint32(ndr, "unknown2", r->unknown2);
5218         ndr_print_uint32(ndr, "length", r->length);
5219         ndr_print_ptr(ndr, "data", r->data);
5220         ndr->depth++;
5221         if (r->data) {
5222                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
5223         }
5224         ndr->depth--;
5225         ndr->depth--;
5226 }
5227
5228 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5229 {
5230         if (ndr_flags & NDR_SCALARS) {
5231                 int level = ndr_push_get_switch_value(ndr, r);
5232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5233                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5234                 switch (level) {
5235                         case 1: {
5236                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5237                         break; }
5238
5239                         default:
5240                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5241                 }
5242         }
5243         if (ndr_flags & NDR_BUFFERS) {
5244                 int level = ndr_push_get_switch_value(ndr, r);
5245                 switch (level) {
5246                         case 1:
5247                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5248                         break;
5249
5250                         default:
5251                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5252                 }
5253         }
5254         return NDR_ERR_SUCCESS;
5255 }
5256
5257 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogRequest *r)
5258 {
5259         int level;
5260         uint32_t _level;
5261         level = ndr_pull_get_switch_value(ndr, r);
5262         if (ndr_flags & NDR_SCALARS) {
5263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5264                 if (_level != level) {
5265                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5266                 }
5267                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5268                 switch (level) {
5269                         case 1: {
5270                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5271                         break; }
5272
5273                         default:
5274                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5275                 }
5276         }
5277         if (ndr_flags & NDR_BUFFERS) {
5278                 switch (level) {
5279                         case 1:
5280                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5281                         break;
5282
5283                         default:
5284                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5285                 }
5286         }
5287         return NDR_ERR_SUCCESS;
5288 }
5289
5290 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5291 {
5292         int level;
5293         level = ndr_print_get_switch_value(ndr, r);
5294         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogRequest");
5295         switch (level) {
5296                 case 1:
5297                         ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(ndr, "req1", &r->req1);
5298                 break;
5299
5300                 default:
5301                         ndr_print_bad_level(ndr, name, level);
5302         }
5303 }
5304
5305 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5306 {
5307         if (ndr_flags & NDR_SCALARS) {
5308                 NDR_CHECK(ndr_push_align(ndr, 8));
5309                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
5310                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
5311                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5312                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time2));
5313                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5314                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time4));
5315                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5316                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time6));
5317                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
5318                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data1));
5319                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data2));
5320                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5321         }
5322         if (ndr_flags & NDR_BUFFERS) {
5323                 if (r->data1) {
5324                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length1));
5325                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data1, r->length1));
5326                 }
5327                 if (r->data2) {
5328                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length2));
5329                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data2, r->length2));
5330                 }
5331         }
5332         return NDR_ERR_SUCCESS;
5333 }
5334
5335 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5336 {
5337         uint32_t _ptr_data1;
5338         TALLOC_CTX *_mem_save_data1_0;
5339         uint32_t _ptr_data2;
5340         TALLOC_CTX *_mem_save_data2_0;
5341         if (ndr_flags & NDR_SCALARS) {
5342                 NDR_CHECK(ndr_pull_align(ndr, 8));
5343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length1));
5344                 if (r->length1 > 0x00A00000) {
5345                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5346                 }
5347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length2));
5348                 if (r->length2 > 0x00A00000) {
5349                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5350                 }
5351                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5352                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time2));
5353                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5354                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time4));
5355                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5356                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time6));
5357                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
5358                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data1));
5359                 if (_ptr_data1) {
5360                         NDR_PULL_ALLOC(ndr, r->data1);
5361                 } else {
5362                         r->data1 = NULL;
5363                 }
5364                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data2));
5365                 if (_ptr_data2) {
5366                         NDR_PULL_ALLOC(ndr, r->data2);
5367                 } else {
5368                         r->data2 = NULL;
5369                 }
5370                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5371         }
5372         if (ndr_flags & NDR_BUFFERS) {
5373                 if (r->data1) {
5374                         _mem_save_data1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5375                         NDR_PULL_SET_MEM_CTX(ndr, r->data1, 0);
5376                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data1));
5377                         NDR_PULL_ALLOC_N(ndr, r->data1, ndr_get_array_size(ndr, &r->data1));
5378                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data1, ndr_get_array_size(ndr, &r->data1)));
5379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data1_0, 0);
5380                 }
5381                 if (r->data2) {
5382                         _mem_save_data2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5383                         NDR_PULL_SET_MEM_CTX(ndr, r->data2, 0);
5384                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data2));
5385                         NDR_PULL_ALLOC_N(ndr, r->data2, ndr_get_array_size(ndr, &r->data2));
5386                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data2, ndr_get_array_size(ndr, &r->data2)));
5387                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data2_0, 0);
5388                 }
5389                 if (r->data1) {
5390                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data1, r->length1));
5391                 }
5392                 if (r->data2) {
5393                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data2, r->length2));
5394                 }
5395         }
5396         return NDR_ERR_SUCCESS;
5397 }
5398
5399 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5400 {
5401         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogInfo1");
5402         ndr->depth++;
5403         ndr_print_uint32(ndr, "length1", r->length1);
5404         ndr_print_uint32(ndr, "length2", r->length2);
5405         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5406         ndr_print_NTTIME(ndr, "time2", r->time2);
5407         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5408         ndr_print_NTTIME(ndr, "time4", r->time4);
5409         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5410         ndr_print_NTTIME(ndr, "time6", r->time6);
5411         ndr_print_NTSTATUS(ndr, "status", r->status);
5412         ndr_print_ptr(ndr, "data1", r->data1);
5413         ndr->depth++;
5414         if (r->data1) {
5415                 ndr_print_array_uint8(ndr, "data1", r->data1, r->length1);
5416         }
5417         ndr->depth--;
5418         ndr_print_ptr(ndr, "data2", r->data2);
5419         ndr->depth++;
5420         if (r->data2) {
5421                 ndr_print_array_uint8(ndr, "data2", r->data2, r->length2);
5422         }
5423         ndr->depth--;
5424         ndr->depth--;
5425 }
5426
5427 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5428 {
5429         if (ndr_flags & NDR_SCALARS) {
5430                 int level = ndr_push_get_switch_value(ndr, r);
5431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5432                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5433                 switch (level) {
5434                         case 1: {
5435                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5436                         break; }
5437
5438                         default:
5439                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5440                 }
5441         }
5442         if (ndr_flags & NDR_BUFFERS) {
5443                 int level = ndr_push_get_switch_value(ndr, r);
5444                 switch (level) {
5445                         case 1:
5446                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5447                         break;
5448
5449                         default:
5450                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5451                 }
5452         }
5453         return NDR_ERR_SUCCESS;
5454 }
5455
5456 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogInfo *r)
5457 {
5458         int level;
5459         uint32_t _level;
5460         level = ndr_pull_get_switch_value(ndr, r);
5461         if (ndr_flags & NDR_SCALARS) {
5462                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5463                 if (_level != level) {
5464                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5465                 }
5466                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5467                 switch (level) {
5468                         case 1: {
5469                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5470                         break; }
5471
5472                         default:
5473                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5474                 }
5475         }
5476         if (ndr_flags & NDR_BUFFERS) {
5477                 switch (level) {
5478                         case 1:
5479                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5480                         break;
5481
5482                         default:
5483                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5484                 }
5485         }
5486         return NDR_ERR_SUCCESS;
5487 }
5488
5489 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5490 {
5491         int level;
5492         level = ndr_print_get_switch_value(ndr, r);
5493         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogInfo");
5494         switch (level) {
5495                 case 1:
5496                         ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(ndr, "info1", &r->info1);
5497                 break;
5498
5499                 default:
5500                         ndr_print_bad_level(ndr, name, level);
5501         }
5502 }
5503
5504 static enum ndr_err_code ndr_push_drsuapi_DsNameStatus(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameStatus r)
5505 {
5506         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5507         return NDR_ERR_SUCCESS;
5508 }
5509
5510 static enum ndr_err_code ndr_pull_drsuapi_DsNameStatus(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameStatus *r)
5511 {
5512         uint32_t v;
5513         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5514         *r = v;
5515         return NDR_ERR_SUCCESS;
5516 }
5517
5518 _PUBLIC_ void ndr_print_drsuapi_DsNameStatus(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameStatus r)
5519 {
5520         const char *val = NULL;
5521
5522         switch (r) {
5523                 case DRSUAPI_DS_NAME_STATUS_OK: val = "DRSUAPI_DS_NAME_STATUS_OK"; break;
5524                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR: val = "DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR"; break;
5525                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND: val = "DRSUAPI_DS_NAME_STATUS_NOT_FOUND"; break;
5526                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE: val = "DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE"; break;
5527                 case DRSUAPI_DS_NAME_STATUS_NO_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_MAPPING"; break;
5528                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY: val = "DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY"; break;
5529                 case DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING"; break;
5530                 case DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL"; break;
5531         }
5532         ndr_print_enum(ndr, name, "ENUM", val, r);
5533 }
5534
5535 static enum ndr_err_code ndr_push_drsuapi_DsNameFlags(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFlags r)
5536 {
5537         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5538         return NDR_ERR_SUCCESS;
5539 }
5540
5541 static enum ndr_err_code ndr_pull_drsuapi_DsNameFlags(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFlags *r)
5542 {
5543         uint32_t v;
5544         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5545         *r = v;
5546         return NDR_ERR_SUCCESS;
5547 }
5548
5549 _PUBLIC_ void ndr_print_drsuapi_DsNameFlags(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFlags r)
5550 {
5551         const char *val = NULL;
5552
5553         switch (r) {
5554                 case DRSUAPI_DS_NAME_FLAG_NO_FLAGS: val = "DRSUAPI_DS_NAME_FLAG_NO_FLAGS"; break;
5555                 case DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY: val = "DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY"; break;
5556                 case DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC: val = "DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC"; break;
5557                 case DRSUAPI_DS_NAME_FLAG_GCVERIFY: val = "DRSUAPI_DS_NAME_FLAG_GCVERIFY"; break;
5558                 case DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL"; break;
5559         }
5560         ndr_print_enum(ndr, name, "ENUM", val, r);
5561 }
5562
5563 static enum ndr_err_code ndr_push_drsuapi_DsNameFormat(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFormat r)
5564 {
5565         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5566         return NDR_ERR_SUCCESS;
5567 }
5568
5569 static enum ndr_err_code ndr_pull_drsuapi_DsNameFormat(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFormat *r)
5570 {
5571         uint32_t v;
5572         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5573         *r = v;
5574         return NDR_ERR_SUCCESS;
5575 }
5576
5577 _PUBLIC_ void ndr_print_drsuapi_DsNameFormat(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFormat r)
5578 {
5579         const char *val = NULL;
5580
5581         switch (r) {
5582                 case DRSUAPI_DS_NAME_FORMAT_UNKNOWN: val = "DRSUAPI_DS_NAME_FORMAT_UNKNOWN"; break;
5583                 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: val = "DRSUAPI_DS_NAME_FORMAT_FQDN_1779"; break;
5584                 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: val = "DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT"; break;
5585                 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: val = "DRSUAPI_DS_NAME_FORMAT_DISPLAY"; break;
5586                 case DRSUAPI_DS_NAME_FORMAT_GUID: val = "DRSUAPI_DS_NAME_FORMAT_GUID"; break;
5587                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL"; break;
5588                 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL"; break;
5589                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX"; break;
5590                 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL"; break;
5591                 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: val = "DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY"; break;
5592                 case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: val = "DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN"; break;
5593         }
5594         ndr_print_enum(ndr, name, "ENUM", val, r);
5595 }
5596
5597 static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameString *r)
5598 {
5599         if (ndr_flags & NDR_SCALARS) {
5600                 NDR_CHECK(ndr_push_align(ndr, 5));
5601                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
5602                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5603         }
5604         if (ndr_flags & NDR_BUFFERS) {
5605                 if (r->str) {
5606                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5607                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5608                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5609                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str, ndr_charset_length(r->str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5610                 }
5611         }
5612         return NDR_ERR_SUCCESS;
5613 }
5614
5615 static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameString *r)
5616 {
5617         uint32_t _ptr_str;
5618         TALLOC_CTX *_mem_save_str_0;
5619         if (ndr_flags & NDR_SCALARS) {
5620                 NDR_CHECK(ndr_pull_align(ndr, 5));
5621                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
5622                 if (_ptr_str) {
5623                         NDR_PULL_ALLOC(ndr, r->str);
5624                 } else {
5625                         r->str = NULL;
5626                 }
5627                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5628         }
5629         if (ndr_flags & NDR_BUFFERS) {
5630                 if (r->str) {
5631                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
5632                         NDR_PULL_SET_MEM_CTX(ndr, r->str, 0);
5633                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str));
5634                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str));
5635                         if (ndr_get_array_length(ndr, &r->str) > ndr_get_array_size(ndr, &r->str)) {
5636                                 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));
5637                         }
5638                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t)));
5639                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t), CH_UTF16));
5640                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
5641                 }
5642         }
5643         return NDR_ERR_SUCCESS;
5644 }
5645
5646 _PUBLIC_ void ndr_print_drsuapi_DsNameString(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameString *r)
5647 {
5648         ndr_print_struct(ndr, name, "drsuapi_DsNameString");
5649         ndr->depth++;
5650         ndr_print_ptr(ndr, "str", r->str);
5651         ndr->depth++;
5652         if (r->str) {
5653                 ndr_print_string(ndr, "str", r->str);
5654         }
5655         ndr->depth--;
5656         ndr->depth--;
5657 }
5658
5659 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameRequest1 *r)
5660 {
5661         uint32_t cntr_names_1;
5662         if (ndr_flags & NDR_SCALARS) {
5663                 NDR_CHECK(ndr_push_align(ndr, 5));
5664                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->codepage));
5665                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->language));
5666                 NDR_CHECK(ndr_push_drsuapi_DsNameFlags(ndr, NDR_SCALARS, r->format_flags));
5667                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_offered));
5668                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
5669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5670                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
5671                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5672         }
5673         if (ndr_flags & NDR_BUFFERS) {
5674                 if (r->names) {
5675                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5676                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5677                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5678                         }
5679                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5680                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5681                         }
5682                 }
5683         }
5684         return NDR_ERR_SUCCESS;
5685 }
5686
5687 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameRequest1 *r)
5688 {
5689         uint32_t _ptr_names;
5690         uint32_t cntr_names_1;
5691         TALLOC_CTX *_mem_save_names_0;
5692         TALLOC_CTX *_mem_save_names_1;
5693         if (ndr_flags & NDR_SCALARS) {
5694                 NDR_CHECK(ndr_pull_align(ndr, 5));
5695                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->codepage));
5696                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->language));
5697                 NDR_CHECK(ndr_pull_drsuapi_DsNameFlags(ndr, NDR_SCALARS, &r->format_flags));
5698                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_offered));
5699                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_desired));
5700                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5701                 if (r->count < 1 || r->count > 10000) {
5702                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5703                 }
5704                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
5705                 if (_ptr_names) {
5706                         NDR_PULL_ALLOC(ndr, r->names);
5707                 } else {
5708                         r->names = NULL;
5709                 }
5710                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5711         }
5712         if (ndr_flags & NDR_BUFFERS) {
5713                 if (r->names) {
5714                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5715                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5716                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
5717                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
5718                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
5719                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5720                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5721                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5722                         }
5723                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5724                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5725                         }
5726                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
5727                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
5728                 }
5729                 if (r->names) {
5730                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
5731                 }
5732         }
5733         return NDR_ERR_SUCCESS;
5734 }
5735
5736 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameRequest1 *r)
5737 {
5738         uint32_t cntr_names_1;
5739         ndr_print_struct(ndr, name, "drsuapi_DsNameRequest1");
5740         ndr->depth++;
5741         ndr_print_uint32(ndr, "codepage", r->codepage);
5742         ndr_print_uint32(ndr, "language", r->language);
5743         ndr_print_drsuapi_DsNameFlags(ndr, "format_flags", r->format_flags);
5744         ndr_print_drsuapi_DsNameFormat(ndr, "format_offered", r->format_offered);
5745         ndr_print_drsuapi_DsNameFormat(ndr, "format_desired", r->format_desired);
5746         ndr_print_uint32(ndr, "count", r->count);
5747         ndr_print_ptr(ndr, "names", r->names);
5748         ndr->depth++;
5749         if (r->names) {
5750                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
5751                 ndr->depth++;
5752                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
5753                         char *idx_1=NULL;
5754                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
5755                                 ndr_print_drsuapi_DsNameString(ndr, "names", &r->names[cntr_names_1]);
5756                                 free(idx_1);
5757                         }
5758                 }
5759                 ndr->depth--;
5760         }
5761         ndr->depth--;
5762         ndr->depth--;
5763 }
5764
5765 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameRequest *r)
5766 {
5767         if (ndr_flags & NDR_SCALARS) {
5768                 int level = ndr_push_get_switch_value(ndr, r);
5769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5770                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5771                 switch (level) {
5772                         case 1: {
5773                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5774                         break; }
5775
5776                         default:
5777                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5778                 }
5779         }
5780         if (ndr_flags & NDR_BUFFERS) {
5781                 int level = ndr_push_get_switch_value(ndr, r);
5782                 switch (level) {
5783                         case 1:
5784                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5785                         break;
5786
5787                         default:
5788                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5789                 }
5790         }
5791         return NDR_ERR_SUCCESS;
5792 }
5793
5794 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameRequest *r)
5795 {
5796         int level;
5797         uint32_t _level;
5798         level = ndr_pull_get_switch_value(ndr, r);
5799         if (ndr_flags & NDR_SCALARS) {
5800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5801                 if (_level != level) {
5802                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5803                 }
5804                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5805                 switch (level) {
5806                         case 1: {
5807                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5808                         break; }
5809
5810                         default:
5811                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5812                 }
5813         }
5814         if (ndr_flags & NDR_BUFFERS) {
5815                 switch (level) {
5816                         case 1:
5817                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5818                         break;
5819
5820                         default:
5821                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5822                 }
5823         }
5824         return NDR_ERR_SUCCESS;
5825 }
5826
5827 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameRequest *r)
5828 {
5829         int level;
5830         level = ndr_print_get_switch_value(ndr, r);
5831         ndr_print_union(ndr, name, level, "drsuapi_DsNameRequest");
5832         switch (level) {
5833                 case 1:
5834                         ndr_print_drsuapi_DsNameRequest1(ndr, "req1", &r->req1);
5835                 break;
5836
5837                 default:
5838                         ndr_print_bad_level(ndr, name, level);
5839         }
5840 }
5841
5842 static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameInfo1 *r)
5843 {
5844         if (ndr_flags & NDR_SCALARS) {
5845                 NDR_CHECK(ndr_push_align(ndr, 5));
5846                 NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
5847                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
5848                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
5849                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5850         }
5851         if (ndr_flags & NDR_BUFFERS) {
5852                 if (r->dns_domain_name) {
5853                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5854                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5855                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5856                         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));
5857                 }
5858                 if (r->result_name) {
5859                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5860                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5861                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5862                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->result_name, ndr_charset_length(r->result_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5863                 }
5864         }
5865         return NDR_ERR_SUCCESS;
5866 }
5867
5868 static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameInfo1 *r)
5869 {
5870         uint32_t _ptr_dns_domain_name;
5871         TALLOC_CTX *_mem_save_dns_domain_name_0;
5872         uint32_t _ptr_result_name;
5873         TALLOC_CTX *_mem_save_result_name_0;
5874         if (ndr_flags & NDR_SCALARS) {
5875                 NDR_CHECK(ndr_pull_align(ndr, 5));
5876                 NDR_CHECK(ndr_pull_drsuapi_DsNameStatus(ndr, NDR_SCALARS, &r->status));
5877                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain_name));
5878                 if (_ptr_dns_domain_name) {
5879                         NDR_PULL_ALLOC(ndr, r->dns_domain_name);
5880                 } else {
5881                         r->dns_domain_name = NULL;
5882                 }
5883                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_result_name));
5884                 if (_ptr_result_name) {
5885                         NDR_PULL_ALLOC(ndr, r->result_name);
5886                 } else {
5887                         r->result_name = NULL;
5888                 }
5889                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5890         }
5891         if (ndr_flags & NDR_BUFFERS) {
5892                 if (r->dns_domain_name) {
5893                         _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5894                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
5895                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain_name));
5896                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain_name));
5897                         if (ndr_get_array_length(ndr, &r->dns_domain_name) > ndr_get_array_size(ndr, &r->dns_domain_name)) {
5898                                 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));
5899                         }
5900                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t)));
5901                         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));
5902                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
5903                 }
5904                 if (r->result_name) {
5905                         _mem_save_result_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5906                         NDR_PULL_SET_MEM_CTX(ndr, r->result_name, 0);
5907                         NDR_CHECK(ndr_pull_array_size(ndr, &r->result_name));
5908                         NDR_CHECK(ndr_pull_array_length(ndr, &r->result_name));
5909                         if (ndr_get_array_length(ndr, &r->result_name) > ndr_get_array_size(ndr, &r->result_name)) {
5910                                 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));
5911                         }
5912                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t)));
5913                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t), CH_UTF16));
5914                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_result_name_0, 0);
5915                 }
5916         }
5917         return NDR_ERR_SUCCESS;
5918 }
5919
5920 _PUBLIC_ void ndr_print_drsuapi_DsNameInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameInfo1 *r)
5921 {
5922         ndr_print_struct(ndr, name, "drsuapi_DsNameInfo1");
5923         ndr->depth++;
5924         ndr_print_drsuapi_DsNameStatus(ndr, "status", r->status);
5925         ndr_print_ptr(ndr, "dns_domain_name", r->dns_domain_name);
5926         ndr->depth++;
5927         if (r->dns_domain_name) {
5928                 ndr_print_string(ndr, "dns_domain_name", r->dns_domain_name);
5929         }
5930         ndr->depth--;
5931         ndr_print_ptr(ndr, "result_name", r->result_name);
5932         ndr->depth++;
5933         if (r->result_name) {
5934                 ndr_print_string(ndr, "result_name", r->result_name);
5935         }
5936         ndr->depth--;
5937         ndr->depth--;
5938 }
5939
5940 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameCtr1 *r)
5941 {
5942         uint32_t cntr_array_1;
5943         if (ndr_flags & NDR_SCALARS) {
5944                 NDR_CHECK(ndr_push_align(ndr, 5));
5945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5946                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5947                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5948         }
5949         if (ndr_flags & NDR_BUFFERS) {
5950                 if (r->array) {
5951                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5952                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5953                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5954                         }
5955                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5956                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5957                         }
5958                 }
5959         }
5960         return NDR_ERR_SUCCESS;
5961 }
5962
5963 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameCtr1 *r)
5964 {
5965         uint32_t _ptr_array;
5966         uint32_t cntr_array_1;
5967         TALLOC_CTX *_mem_save_array_0;
5968         TALLOC_CTX *_mem_save_array_1;
5969         if (ndr_flags & NDR_SCALARS) {
5970                 NDR_CHECK(ndr_pull_align(ndr, 5));
5971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5972                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
5973                 if (_ptr_array) {
5974                         NDR_PULL_ALLOC(ndr, r->array);
5975                 } else {
5976                         r->array = NULL;
5977                 }
5978                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5979         }
5980         if (ndr_flags & NDR_BUFFERS) {
5981                 if (r->array) {
5982                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5983                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5984                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
5985                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
5986                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5987                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
5988                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5989                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5990                         }
5991                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5992                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
5993                         }
5994                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
5995                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
5996                 }
5997                 if (r->array) {
5998                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
5999                 }
6000         }
6001         return NDR_ERR_SUCCESS;
6002 }
6003
6004 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameCtr1 *r)
6005 {
6006         uint32_t cntr_array_1;
6007         ndr_print_struct(ndr, name, "drsuapi_DsNameCtr1");
6008         ndr->depth++;
6009         ndr_print_uint32(ndr, "count", r->count);
6010         ndr_print_ptr(ndr, "array", r->array);
6011         ndr->depth++;
6012         if (r->array) {
6013                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
6014                 ndr->depth++;
6015                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
6016                         char *idx_1=NULL;
6017                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
6018                                 ndr_print_drsuapi_DsNameInfo1(ndr, "array", &r->array[cntr_array_1]);
6019                                 free(idx_1);
6020                         }
6021                 }
6022                 ndr->depth--;
6023         }
6024         ndr->depth--;
6025         ndr->depth--;
6026 }
6027
6028 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameCtr *r)
6029 {
6030         if (ndr_flags & NDR_SCALARS) {
6031                 int level = ndr_push_get_switch_value(ndr, r);
6032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6033                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6034                 switch (level) {
6035                         case 1: {
6036                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
6037                         break; }
6038
6039                         default:
6040                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6041                 }
6042         }
6043         if (ndr_flags & NDR_BUFFERS) {
6044                 int level = ndr_push_get_switch_value(ndr, r);
6045                 switch (level) {
6046                         case 1:
6047                                 if (r->ctr1) {
6048                                         NDR_CHECK(ndr_push_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6049                                 }
6050                         break;
6051
6052                         default:
6053                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6054                 }
6055         }
6056         return NDR_ERR_SUCCESS;
6057 }
6058
6059 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameCtr *r)
6060 {
6061         int level;
6062         uint32_t _level;
6063         TALLOC_CTX *_mem_save_ctr1_0;
6064         level = ndr_pull_get_switch_value(ndr, r);
6065         if (ndr_flags & NDR_SCALARS) {
6066                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6067                 if (_level != level) {
6068                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6069                 }
6070                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6071                 switch (level) {
6072                         case 1: {
6073                                 uint32_t _ptr_ctr1;
6074                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
6075                                 if (_ptr_ctr1) {
6076                                         NDR_PULL_ALLOC(ndr, r->ctr1);
6077                                 } else {
6078                                         r->ctr1 = NULL;
6079                                 }
6080                         break; }
6081
6082                         default:
6083                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6084                 }
6085         }
6086         if (ndr_flags & NDR_BUFFERS) {
6087                 switch (level) {
6088                         case 1:
6089                                 if (r->ctr1) {
6090                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6091                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
6092                                         NDR_CHECK(ndr_pull_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6093                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
6094                                 }
6095                         break;
6096
6097                         default:
6098                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6099                 }
6100         }
6101         return NDR_ERR_SUCCESS;
6102 }
6103
6104 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameCtr *r)
6105 {
6106         int level;
6107         level = ndr_print_get_switch_value(ndr, r);
6108         ndr_print_union(ndr, name, level, "drsuapi_DsNameCtr");
6109         switch (level) {
6110                 case 1:
6111                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
6112                         ndr->depth++;
6113                         if (r->ctr1) {
6114                                 ndr_print_drsuapi_DsNameCtr1(ndr, "ctr1", r->ctr1);
6115                         }
6116                         ndr->depth--;
6117                 break;
6118
6119                 default:
6120                         ndr_print_bad_level(ndr, name, level);
6121         }
6122 }
6123
6124 static enum ndr_err_code ndr_push_drsuapi_DsSpnOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsSpnOperation r)
6125 {
6126         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6127         return NDR_ERR_SUCCESS;
6128 }
6129
6130 static enum ndr_err_code ndr_pull_drsuapi_DsSpnOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsSpnOperation *r)
6131 {
6132         uint32_t v;
6133         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6134         *r = v;
6135         return NDR_ERR_SUCCESS;
6136 }
6137
6138 _PUBLIC_ void ndr_print_drsuapi_DsSpnOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsSpnOperation r)
6139 {
6140         const char *val = NULL;
6141
6142         switch (r) {
6143                 case DRSUAPI_DS_SPN_OPERATION_ADD: val = "DRSUAPI_DS_SPN_OPERATION_ADD"; break;
6144                 case DRSUAPI_DS_SPN_OPERATION_REPLACE: val = "DRSUAPI_DS_SPN_OPERATION_REPLACE"; break;
6145                 case DRSUAPI_DS_SPN_OPERATION_DELETE: val = "DRSUAPI_DS_SPN_OPERATION_DELETE"; break;
6146         }
6147         ndr_print_enum(ndr, name, "ENUM", val, r);
6148 }
6149
6150 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6151 {
6152         uint32_t cntr_spn_names_1;
6153         if (ndr_flags & NDR_SCALARS) {
6154                 NDR_CHECK(ndr_push_align(ndr, 5));
6155                 NDR_CHECK(ndr_push_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, r->operation));
6156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
6157                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
6158                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6159                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
6160                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6161         }
6162         if (ndr_flags & NDR_BUFFERS) {
6163                 if (r->object_dn) {
6164                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6165                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6166                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6167                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6168                 }
6169                 if (r->spn_names) {
6170                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6171                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6172                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6173                         }
6174                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6175                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6176                         }
6177                 }
6178         }
6179         return NDR_ERR_SUCCESS;
6180 }
6181
6182 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnRequest1 *r)
6183 {
6184         uint32_t _ptr_object_dn;
6185         TALLOC_CTX *_mem_save_object_dn_0;
6186         uint32_t _ptr_spn_names;
6187         uint32_t cntr_spn_names_1;
6188         TALLOC_CTX *_mem_save_spn_names_0;
6189         TALLOC_CTX *_mem_save_spn_names_1;
6190         if (ndr_flags & NDR_SCALARS) {
6191                 NDR_CHECK(ndr_pull_align(ndr, 5));
6192                 NDR_CHECK(ndr_pull_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, &r->operation));
6193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
6194                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
6195                 if (_ptr_object_dn) {
6196                         NDR_PULL_ALLOC(ndr, r->object_dn);
6197                 } else {
6198                         r->object_dn = NULL;
6199                 }
6200                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6201                 if (r->count > 10000) {
6202                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6203                 }
6204                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_spn_names));
6205                 if (_ptr_spn_names) {
6206                         NDR_PULL_ALLOC(ndr, r->spn_names);
6207                 } else {
6208                         r->spn_names = NULL;
6209                 }
6210                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6211         }
6212         if (ndr_flags & NDR_BUFFERS) {
6213                 if (r->object_dn) {
6214                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6215                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
6216                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
6217                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
6218                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
6219                                 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));
6220                         }
6221                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
6222                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
6223                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
6224                 }
6225                 if (r->spn_names) {
6226                         _mem_save_spn_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6227                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6228                         NDR_CHECK(ndr_pull_array_size(ndr, &r->spn_names));
6229                         NDR_PULL_ALLOC_N(ndr, r->spn_names, ndr_get_array_size(ndr, &r->spn_names));
6230                         _mem_save_spn_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
6231                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6232                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6233                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6234                         }
6235                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6236                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6237                         }
6238                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_1, 0);
6239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_0, 0);
6240                 }
6241                 if (r->spn_names) {
6242                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->spn_names, r->count));
6243                 }
6244         }
6245         return NDR_ERR_SUCCESS;
6246 }
6247
6248 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6249 {
6250         uint32_t cntr_spn_names_1;
6251         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnRequest1");
6252         ndr->depth++;
6253         ndr_print_drsuapi_DsSpnOperation(ndr, "operation", r->operation);
6254         ndr_print_uint32(ndr, "unknown1", r->unknown1);
6255         ndr_print_ptr(ndr, "object_dn", r->object_dn);
6256         ndr->depth++;
6257         if (r->object_dn) {
6258                 ndr_print_string(ndr, "object_dn", r->object_dn);
6259         }
6260         ndr->depth--;
6261         ndr_print_uint32(ndr, "count", r->count);
6262         ndr_print_ptr(ndr, "spn_names", r->spn_names);
6263         ndr->depth++;
6264         if (r->spn_names) {
6265                 ndr->print(ndr, "%s: ARRAY(%d)", "spn_names", (int)r->count);
6266                 ndr->depth++;
6267                 for (cntr_spn_names_1=0;cntr_spn_names_1<r->count;cntr_spn_names_1++) {
6268                         char *idx_1=NULL;
6269                         if (asprintf(&idx_1, "[%d]", cntr_spn_names_1) != -1) {
6270                                 ndr_print_drsuapi_DsNameString(ndr, "spn_names", &r->spn_names[cntr_spn_names_1]);
6271                                 free(idx_1);
6272                         }
6273                 }
6274                 ndr->depth--;
6275         }
6276         ndr->depth--;
6277         ndr->depth--;
6278 }
6279
6280 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnRequest *r)
6281 {
6282         if (ndr_flags & NDR_SCALARS) {
6283                 int level = ndr_push_get_switch_value(ndr, r);
6284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6285                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6286                 switch (level) {
6287                         case 1: {
6288                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6289                         break; }
6290
6291                         default:
6292                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6293                 }
6294         }
6295         if (ndr_flags & NDR_BUFFERS) {
6296                 int level = ndr_push_get_switch_value(ndr, r);
6297                 switch (level) {
6298                         case 1:
6299                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6300                         break;
6301
6302                         default:
6303                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6304                 }
6305         }
6306         return NDR_ERR_SUCCESS;
6307 }
6308
6309 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnRequest *r)
6310 {
6311         int level;
6312         uint32_t _level;
6313         level = ndr_pull_get_switch_value(ndr, r);
6314         if (ndr_flags & NDR_SCALARS) {
6315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6316                 if (_level != level) {
6317                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6318                 }
6319                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6320                 switch (level) {
6321                         case 1: {
6322                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6323                         break; }
6324
6325                         default:
6326                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6327                 }
6328         }
6329         if (ndr_flags & NDR_BUFFERS) {
6330                 switch (level) {
6331                         case 1:
6332                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6333                         break;
6334
6335                         default:
6336                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6337                 }
6338         }
6339         return NDR_ERR_SUCCESS;
6340 }
6341
6342 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnRequest *r)
6343 {
6344         int level;
6345         level = ndr_print_get_switch_value(ndr, r);
6346         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnRequest");
6347         switch (level) {
6348                 case 1:
6349                         ndr_print_drsuapi_DsWriteAccountSpnRequest1(ndr, "req1", &r->req1);
6350                 break;
6351
6352                 default:
6353                         ndr_print_bad_level(ndr, name, level);
6354         }
6355 }
6356
6357 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6358 {
6359         if (ndr_flags & NDR_SCALARS) {
6360                 NDR_CHECK(ndr_push_align(ndr, 4));
6361                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
6362                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6363         }
6364         if (ndr_flags & NDR_BUFFERS) {
6365         }
6366         return NDR_ERR_SUCCESS;
6367 }
6368
6369 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnResult1 *r)
6370 {
6371         if (ndr_flags & NDR_SCALARS) {
6372                 NDR_CHECK(ndr_pull_align(ndr, 4));
6373                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
6374                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6375         }
6376         if (ndr_flags & NDR_BUFFERS) {
6377         }
6378         return NDR_ERR_SUCCESS;
6379 }
6380
6381 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6382 {
6383         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnResult1");
6384         ndr->depth++;
6385         ndr_print_WERROR(ndr, "status", r->status);
6386         ndr->depth--;
6387 }
6388
6389 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnResult *r)
6390 {
6391         if (ndr_flags & NDR_SCALARS) {
6392                 int level = ndr_push_get_switch_value(ndr, r);
6393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6394                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6395                 switch (level) {
6396                         case 1: {
6397                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6398                         break; }
6399
6400                         default:
6401                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6402                 }
6403         }
6404         if (ndr_flags & NDR_BUFFERS) {
6405                 int level = ndr_push_get_switch_value(ndr, r);
6406                 switch (level) {
6407                         case 1:
6408                         break;
6409
6410                         default:
6411                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6412                 }
6413         }
6414         return NDR_ERR_SUCCESS;
6415 }
6416
6417 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnResult *r)
6418 {
6419         int level;
6420         uint32_t _level;
6421         level = ndr_pull_get_switch_value(ndr, r);
6422         if (ndr_flags & NDR_SCALARS) {
6423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6424                 if (_level != level) {
6425                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6426                 }
6427                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6428                 switch (level) {
6429                         case 1: {
6430                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6431                         break; }
6432
6433                         default:
6434                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6435                 }
6436         }
6437         if (ndr_flags & NDR_BUFFERS) {
6438                 switch (level) {
6439                         case 1:
6440                         break;
6441
6442                         default:
6443                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6444                 }
6445         }
6446         return NDR_ERR_SUCCESS;
6447 }
6448
6449 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnResult *r)
6450 {
6451         int level;
6452         level = ndr_print_get_switch_value(ndr, r);
6453         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnResult");
6454         switch (level) {
6455                 case 1:
6456                         ndr_print_drsuapi_DsWriteAccountSpnResult1(ndr, "res1", &r->res1);
6457                 break;
6458
6459                 default:
6460                         ndr_print_bad_level(ndr, name, level);
6461         }
6462 }
6463
6464 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6465 {
6466         if (ndr_flags & NDR_SCALARS) {
6467                 NDR_CHECK(ndr_push_align(ndr, 5));
6468                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6469                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
6470                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->commit));
6471                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6472         }
6473         if (ndr_flags & NDR_BUFFERS) {
6474                 if (r->server_dn) {
6475                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6476                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6477                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6478                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6479                 }
6480                 if (r->domain_dn) {
6481                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6482                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6483                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6484                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_dn, ndr_charset_length(r->domain_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6485                 }
6486         }
6487         return NDR_ERR_SUCCESS;
6488 }
6489
6490 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerRequest1 *r)
6491 {
6492         uint32_t _ptr_server_dn;
6493         TALLOC_CTX *_mem_save_server_dn_0;
6494         uint32_t _ptr_domain_dn;
6495         TALLOC_CTX *_mem_save_domain_dn_0;
6496         if (ndr_flags & NDR_SCALARS) {
6497                 NDR_CHECK(ndr_pull_align(ndr, 5));
6498                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6499                 if (_ptr_server_dn) {
6500                         NDR_PULL_ALLOC(ndr, r->server_dn);
6501                 } else {
6502                         r->server_dn = NULL;
6503                 }
6504                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_dn));
6505                 if (_ptr_domain_dn) {
6506                         NDR_PULL_ALLOC(ndr, r->domain_dn);
6507                 } else {
6508                         r->domain_dn = NULL;
6509                 }
6510                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->commit));
6511                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6512         }
6513         if (ndr_flags & NDR_BUFFERS) {
6514                 if (r->server_dn) {
6515                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6516                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6517                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6518                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6519                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6520                                 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));
6521                         }
6522                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6523                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6524                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6525                 }
6526                 if (r->domain_dn) {
6527                         _mem_save_domain_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6528                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_dn, 0);
6529                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_dn));
6530                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_dn));
6531                         if (ndr_get_array_length(ndr, &r->domain_dn) > ndr_get_array_size(ndr, &r->domain_dn)) {
6532                                 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));
6533                         }
6534                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t)));
6535                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t), CH_UTF16));
6536                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_dn_0, 0);
6537                 }
6538         }
6539         return NDR_ERR_SUCCESS;
6540 }
6541
6542 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6543 {
6544         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerRequest1");
6545         ndr->depth++;
6546         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6547         ndr->depth++;
6548         if (r->server_dn) {
6549                 ndr_print_string(ndr, "server_dn", r->server_dn);
6550         }
6551         ndr->depth--;
6552         ndr_print_ptr(ndr, "domain_dn", r->domain_dn);
6553         ndr->depth++;
6554         if (r->domain_dn) {
6555                 ndr_print_string(ndr, "domain_dn", r->domain_dn);
6556         }
6557         ndr->depth--;
6558         ndr_print_uint32(ndr, "commit", r->commit);
6559         ndr->depth--;
6560 }
6561
6562 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerRequest *r)
6563 {
6564         if (ndr_flags & NDR_SCALARS) {
6565                 int level = ndr_push_get_switch_value(ndr, r);
6566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6567                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6568                 switch (level) {
6569                         case 1: {
6570                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6571                         break; }
6572
6573                         default:
6574                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6575                 }
6576         }
6577         if (ndr_flags & NDR_BUFFERS) {
6578                 int level = ndr_push_get_switch_value(ndr, r);
6579                 switch (level) {
6580                         case 1:
6581                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6582                         break;
6583
6584                         default:
6585                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6586                 }
6587         }
6588         return NDR_ERR_SUCCESS;
6589 }
6590
6591 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerRequest *r)
6592 {
6593         int level;
6594         uint32_t _level;
6595         level = ndr_pull_get_switch_value(ndr, r);
6596         if (ndr_flags & NDR_SCALARS) {
6597                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6598                 if (_level != level) {
6599                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6600                 }
6601                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6602                 switch (level) {
6603                         case 1: {
6604                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6605                         break; }
6606
6607                         default:
6608                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6609                 }
6610         }
6611         if (ndr_flags & NDR_BUFFERS) {
6612                 switch (level) {
6613                         case 1:
6614                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6615                         break;
6616
6617                         default:
6618                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6619                 }
6620         }
6621         return NDR_ERR_SUCCESS;
6622 }
6623
6624 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerRequest *r)
6625 {
6626         int level;
6627         level = ndr_print_get_switch_value(ndr, r);
6628         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerRequest");
6629         switch (level) {
6630                 case 1:
6631                         ndr_print_drsuapi_DsRemoveDSServerRequest1(ndr, "req1", &r->req1);
6632                 break;
6633
6634                 default:
6635                         ndr_print_bad_level(ndr, name, level);
6636         }
6637 }
6638
6639 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerResult1 *r)
6640 {
6641         if (ndr_flags & NDR_SCALARS) {
6642                 NDR_CHECK(ndr_push_align(ndr, 4));
6643                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->last_dc_in_domain));
6644                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6645         }
6646         if (ndr_flags & NDR_BUFFERS) {
6647         }
6648         return NDR_ERR_SUCCESS;
6649 }
6650
6651 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerResult1 *r)
6652 {
6653         if (ndr_flags & NDR_SCALARS) {
6654                 NDR_CHECK(ndr_pull_align(ndr, 4));
6655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->last_dc_in_domain));
6656                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6657         }
6658         if (ndr_flags & NDR_BUFFERS) {
6659         }
6660         return NDR_ERR_SUCCESS;
6661 }
6662
6663 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerResult1 *r)
6664 {
6665         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerResult1");
6666         ndr->depth++;
6667         ndr_print_uint32(ndr, "last_dc_in_domain", r->last_dc_in_domain);
6668         ndr->depth--;
6669 }
6670
6671 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerResult *r)
6672 {
6673         if (ndr_flags & NDR_SCALARS) {
6674                 int level = ndr_push_get_switch_value(ndr, r);
6675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6676                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6677                 switch (level) {
6678                         case 1: {
6679                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6680                         break; }
6681
6682                         default:
6683                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6684                 }
6685         }
6686         if (ndr_flags & NDR_BUFFERS) {
6687                 int level = ndr_push_get_switch_value(ndr, r);
6688                 switch (level) {
6689                         case 1:
6690                         break;
6691
6692                         default:
6693                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6694                 }
6695         }
6696         return NDR_ERR_SUCCESS;
6697 }
6698
6699 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerResult *r)
6700 {
6701         int level;
6702         uint32_t _level;
6703         level = ndr_pull_get_switch_value(ndr, r);
6704         if (ndr_flags & NDR_SCALARS) {
6705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6706                 if (_level != level) {
6707                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6708                 }
6709                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6710                 switch (level) {
6711                         case 1: {
6712                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6713                         break; }
6714
6715                         default:
6716                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6717                 }
6718         }
6719         if (ndr_flags & NDR_BUFFERS) {
6720                 switch (level) {
6721                         case 1:
6722                         break;
6723
6724                         default:
6725                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6726                 }
6727         }
6728         return NDR_ERR_SUCCESS;
6729 }
6730
6731 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerResult *r)
6732 {
6733         int level;
6734         level = ndr_print_get_switch_value(ndr, r);
6735         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerResult");
6736         switch (level) {
6737                 case 1:
6738                         ndr_print_drsuapi_DsRemoveDSServerResult1(ndr, "res1", &r->res1);
6739                 break;
6740
6741                 default:
6742                         ndr_print_bad_level(ndr, name, level);
6743         }
6744 }
6745
6746 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoRequest1 *r)
6747 {
6748         if (ndr_flags & NDR_SCALARS) {
6749                 NDR_CHECK(ndr_push_align(ndr, 5));
6750                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
6751                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
6752                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6753         }
6754         if (ndr_flags & NDR_BUFFERS) {
6755                 if (r->domain_name) {
6756                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6757                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6758                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6759                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6760                 }
6761         }
6762         return NDR_ERR_SUCCESS;
6763 }
6764
6765 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoRequest1 *r)
6766 {
6767         uint32_t _ptr_domain_name;
6768         TALLOC_CTX *_mem_save_domain_name_0;
6769         if (ndr_flags & NDR_SCALARS) {
6770                 NDR_CHECK(ndr_pull_align(ndr, 5));
6771                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
6772                 if (_ptr_domain_name) {
6773                         NDR_PULL_ALLOC(ndr, r->domain_name);
6774                 } else {
6775                         r->domain_name = NULL;
6776                 }
6777                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
6778                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6779         }
6780         if (ndr_flags & NDR_BUFFERS) {
6781                 if (r->domain_name) {
6782                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6783                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
6784                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
6785                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
6786                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
6787                                 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));
6788                         }
6789                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
6790                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
6791                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
6792                 }
6793         }
6794         return NDR_ERR_SUCCESS;
6795 }
6796
6797 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoRequest1 *r)
6798 {
6799         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoRequest1");
6800         ndr->depth++;
6801         ndr_print_ptr(ndr, "domain_name", r->domain_name);
6802         ndr->depth++;
6803         if (r->domain_name) {
6804                 ndr_print_string(ndr, "domain_name", r->domain_name);
6805         }
6806         ndr->depth--;
6807         ndr_print_int32(ndr, "level", r->level);
6808         ndr->depth--;
6809 }
6810
6811 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoRequest *r)
6812 {
6813         if (ndr_flags & NDR_SCALARS) {
6814                 int level = ndr_push_get_switch_value(ndr, r);
6815                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6816                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6817                 switch (level) {
6818                         case 1: {
6819                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6820                         break; }
6821
6822                         default:
6823                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6824                 }
6825         }
6826         if (ndr_flags & NDR_BUFFERS) {
6827                 int level = ndr_push_get_switch_value(ndr, r);
6828                 switch (level) {
6829                         case 1:
6830                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6831                         break;
6832
6833                         default:
6834                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6835                 }
6836         }
6837         return NDR_ERR_SUCCESS;
6838 }
6839
6840 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoRequest *r)
6841 {
6842         int level;
6843         int32_t _level;
6844         level = ndr_pull_get_switch_value(ndr, r);
6845         if (ndr_flags & NDR_SCALARS) {
6846                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6847                 if (_level != level) {
6848                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6849                 }
6850                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6851                 switch (level) {
6852                         case 1: {
6853                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6854                         break; }
6855
6856                         default:
6857                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6858                 }
6859         }
6860         if (ndr_flags & NDR_BUFFERS) {
6861                 switch (level) {
6862                         case 1:
6863                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6864                         break;
6865
6866                         default:
6867                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6868                 }
6869         }
6870         return NDR_ERR_SUCCESS;
6871 }
6872
6873 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoRequest *r)
6874 {
6875         int level;
6876         level = ndr_print_get_switch_value(ndr, r);
6877         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoRequest");
6878         switch (level) {
6879                 case 1:
6880                         ndr_print_drsuapi_DsGetDCInfoRequest1(ndr, "req1", &r->req1);
6881                 break;
6882
6883                 default:
6884                         ndr_print_bad_level(ndr, name, level);
6885         }
6886 }
6887
6888 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo1 *r)
6889 {
6890         if (ndr_flags & NDR_SCALARS) {
6891                 NDR_CHECK(ndr_push_align(ndr, 5));
6892                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6893                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6894                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6895                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6896                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6898                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6899                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6900         }
6901         if (ndr_flags & NDR_BUFFERS) {
6902                 if (r->netbios_name) {
6903                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6904                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6905                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6906                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6907                 }
6908                 if (r->dns_name) {
6909                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6910                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6911                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6912                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6913                 }
6914                 if (r->site_name) {
6915                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6916                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6917                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6918                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6919                 }
6920                 if (r->computer_dn) {
6921                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6922                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6923                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6924                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6925                 }
6926                 if (r->server_dn) {
6927                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6928                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6929                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6930                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6931                 }
6932         }
6933         return NDR_ERR_SUCCESS;
6934 }
6935
6936 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo1 *r)
6937 {
6938         uint32_t _ptr_netbios_name;
6939         TALLOC_CTX *_mem_save_netbios_name_0;
6940         uint32_t _ptr_dns_name;
6941         TALLOC_CTX *_mem_save_dns_name_0;
6942         uint32_t _ptr_site_name;
6943         TALLOC_CTX *_mem_save_site_name_0;
6944         uint32_t _ptr_computer_dn;
6945         TALLOC_CTX *_mem_save_computer_dn_0;
6946         uint32_t _ptr_server_dn;
6947         TALLOC_CTX *_mem_save_server_dn_0;
6948         if (ndr_flags & NDR_SCALARS) {
6949                 NDR_CHECK(ndr_pull_align(ndr, 5));
6950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
6951                 if (_ptr_netbios_name) {
6952                         NDR_PULL_ALLOC(ndr, r->netbios_name);
6953                 } else {
6954                         r->netbios_name = NULL;
6955                 }
6956                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
6957                 if (_ptr_dns_name) {
6958                         NDR_PULL_ALLOC(ndr, r->dns_name);
6959                 } else {
6960                         r->dns_name = NULL;
6961                 }
6962                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
6963                 if (_ptr_site_name) {
6964                         NDR_PULL_ALLOC(ndr, r->site_name);
6965                 } else {
6966                         r->site_name = NULL;
6967                 }
6968                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
6969                 if (_ptr_computer_dn) {
6970                         NDR_PULL_ALLOC(ndr, r->computer_dn);
6971                 } else {
6972                         r->computer_dn = NULL;
6973                 }
6974                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6975                 if (_ptr_server_dn) {
6976                         NDR_PULL_ALLOC(ndr, r->server_dn);
6977                 } else {
6978                         r->server_dn = NULL;
6979                 }
6980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
6981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
6982                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6983         }
6984         if (ndr_flags & NDR_BUFFERS) {
6985                 if (r->netbios_name) {
6986                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6987                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
6988                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
6989                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
6990                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
6991                                 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));
6992                         }
6993                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
6994                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
6995                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
6996                 }
6997                 if (r->dns_name) {
6998                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6999                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7000                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7001                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7002                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7003                                 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));
7004                         }
7005                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7006                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7007                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7008                 }
7009                 if (r->site_name) {
7010                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7011                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7012                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7013                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7014                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7015                                 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));
7016                         }
7017                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7018                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7019                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7020                 }
7021                 if (r->computer_dn) {
7022                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7023                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7024                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7025                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7026                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7027                                 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));
7028                         }
7029                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7030                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7031                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7032                 }
7033                 if (r->server_dn) {
7034                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7035                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7036                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7037                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7038                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7039                                 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));
7040                         }
7041                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7042                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7044                 }
7045         }
7046         return NDR_ERR_SUCCESS;
7047 }
7048
7049 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo1 *r)
7050 {
7051         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo1");
7052         ndr->depth++;
7053         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7054         ndr->depth++;
7055         if (r->netbios_name) {
7056                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7057         }
7058         ndr->depth--;
7059         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7060         ndr->depth++;
7061         if (r->dns_name) {
7062                 ndr_print_string(ndr, "dns_name", r->dns_name);
7063         }
7064         ndr->depth--;
7065         ndr_print_ptr(ndr, "site_name", r->site_name);
7066         ndr->depth++;
7067         if (r->site_name) {
7068                 ndr_print_string(ndr, "site_name", r->site_name);
7069         }
7070         ndr->depth--;
7071         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7072         ndr->depth++;
7073         if (r->computer_dn) {
7074                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7075         }
7076         ndr->depth--;
7077         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7078         ndr->depth++;
7079         if (r->server_dn) {
7080                 ndr_print_string(ndr, "server_dn", r->server_dn);
7081         }
7082         ndr->depth--;
7083         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7084         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7085         ndr->depth--;
7086 }
7087
7088 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr1 *r)
7089 {
7090         uint32_t cntr_array_1;
7091         if (ndr_flags & NDR_SCALARS) {
7092                 NDR_CHECK(ndr_push_align(ndr, 5));
7093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7094                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7095                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7096         }
7097         if (ndr_flags & NDR_BUFFERS) {
7098                 if (r->array) {
7099                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7100                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7101                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7102                         }
7103                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7104                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7105                         }
7106                 }
7107         }
7108         return NDR_ERR_SUCCESS;
7109 }
7110
7111 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr1 *r)
7112 {
7113         uint32_t _ptr_array;
7114         uint32_t cntr_array_1;
7115         TALLOC_CTX *_mem_save_array_0;
7116         TALLOC_CTX *_mem_save_array_1;
7117         if (ndr_flags & NDR_SCALARS) {
7118                 NDR_CHECK(ndr_pull_align(ndr, 5));
7119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7120                 if (r->count > 10000) {
7121                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7122                 }
7123                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7124                 if (_ptr_array) {
7125                         NDR_PULL_ALLOC(ndr, r->array);
7126                 } else {
7127                         r->array = NULL;
7128                 }
7129                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7130         }
7131         if (ndr_flags & NDR_BUFFERS) {
7132                 if (r->array) {
7133                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7134                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7135                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7136                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7137                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7138                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7139                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7140                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7141                         }
7142                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7143                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7144                         }
7145                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7147                 }
7148                 if (r->array) {
7149                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7150                 }
7151         }
7152         return NDR_ERR_SUCCESS;
7153 }
7154
7155 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr1 *r)
7156 {
7157         uint32_t cntr_array_1;
7158         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr1");
7159         ndr->depth++;
7160         ndr_print_uint32(ndr, "count", r->count);
7161         ndr_print_ptr(ndr, "array", r->array);
7162         ndr->depth++;
7163         if (r->array) {
7164                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7165                 ndr->depth++;
7166                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7167                         char *idx_1=NULL;
7168                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7169                                 ndr_print_drsuapi_DsGetDCInfo1(ndr, "array", &r->array[cntr_array_1]);
7170                                 free(idx_1);
7171                         }
7172                 }
7173                 ndr->depth--;
7174         }
7175         ndr->depth--;
7176         ndr->depth--;
7177 }
7178
7179 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo2 *r)
7180 {
7181         if (ndr_flags & NDR_SCALARS) {
7182                 NDR_CHECK(ndr_push_align(ndr, 5));
7183                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7184                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7185                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7186                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7187                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7188                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7189                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7192                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7193                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7194                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7195                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7196                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7197                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7198         }
7199         if (ndr_flags & NDR_BUFFERS) {
7200                 if (r->netbios_name) {
7201                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7202                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7203                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7204                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7205                 }
7206                 if (r->dns_name) {
7207                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7208                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7209                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7210                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7211                 }
7212                 if (r->site_name) {
7213                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7214                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7215                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7216                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7217                 }
7218                 if (r->site_dn) {
7219                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7220                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7221                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7222                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7223                 }
7224                 if (r->computer_dn) {
7225                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7226                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7227                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7228                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7229                 }
7230                 if (r->server_dn) {
7231                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7232                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7233                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7234                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7235                 }
7236                 if (r->ntds_dn) {
7237                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7238                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7239                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7240                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7241                 }
7242         }
7243         return NDR_ERR_SUCCESS;
7244 }
7245
7246 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo2 *r)
7247 {
7248         uint32_t _ptr_netbios_name;
7249         TALLOC_CTX *_mem_save_netbios_name_0;
7250         uint32_t _ptr_dns_name;
7251         TALLOC_CTX *_mem_save_dns_name_0;
7252         uint32_t _ptr_site_name;
7253         TALLOC_CTX *_mem_save_site_name_0;
7254         uint32_t _ptr_site_dn;
7255         TALLOC_CTX *_mem_save_site_dn_0;
7256         uint32_t _ptr_computer_dn;
7257         TALLOC_CTX *_mem_save_computer_dn_0;
7258         uint32_t _ptr_server_dn;
7259         TALLOC_CTX *_mem_save_server_dn_0;
7260         uint32_t _ptr_ntds_dn;
7261         TALLOC_CTX *_mem_save_ntds_dn_0;
7262         if (ndr_flags & NDR_SCALARS) {
7263                 NDR_CHECK(ndr_pull_align(ndr, 5));
7264                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7265                 if (_ptr_netbios_name) {
7266                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7267                 } else {
7268                         r->netbios_name = NULL;
7269                 }
7270                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7271                 if (_ptr_dns_name) {
7272                         NDR_PULL_ALLOC(ndr, r->dns_name);
7273                 } else {
7274                         r->dns_name = NULL;
7275                 }
7276                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7277                 if (_ptr_site_name) {
7278                         NDR_PULL_ALLOC(ndr, r->site_name);
7279                 } else {
7280                         r->site_name = NULL;
7281                 }
7282                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7283                 if (_ptr_site_dn) {
7284                         NDR_PULL_ALLOC(ndr, r->site_dn);
7285                 } else {
7286                         r->site_dn = NULL;
7287                 }
7288                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7289                 if (_ptr_computer_dn) {
7290                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7291                 } else {
7292                         r->computer_dn = NULL;
7293                 }
7294                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7295                 if (_ptr_server_dn) {
7296                         NDR_PULL_ALLOC(ndr, r->server_dn);
7297                 } else {
7298                         r->server_dn = NULL;
7299                 }
7300                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7301                 if (_ptr_ntds_dn) {
7302                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7303                 } else {
7304                         r->ntds_dn = NULL;
7305                 }
7306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7307                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7309                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7310                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7311                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7312                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7313                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7314         }
7315         if (ndr_flags & NDR_BUFFERS) {
7316                 if (r->netbios_name) {
7317                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7318                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7319                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7320                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7321                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7322                                 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));
7323                         }
7324                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7325                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7326                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7327                 }
7328                 if (r->dns_name) {
7329                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7330                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7331                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7332                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7333                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7334                                 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));
7335                         }
7336                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7337                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7338                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7339                 }
7340                 if (r->site_name) {
7341                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7342                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7343                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7344                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7345                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7346                                 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));
7347                         }
7348                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7349                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7350                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7351                 }
7352                 if (r->site_dn) {
7353                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7354                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7355                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7356                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7357                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7358                                 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));
7359                         }
7360                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7361                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7362                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7363                 }
7364                 if (r->computer_dn) {
7365                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7366                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7367                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7368                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7369                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7370                                 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));
7371                         }
7372                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7373                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7374                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7375                 }
7376                 if (r->server_dn) {
7377                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7378                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7379                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7380                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7381                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7382                                 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));
7383                         }
7384                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7385                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7386                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7387                 }
7388                 if (r->ntds_dn) {
7389                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7390                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7391                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7392                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7393                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7394                                 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));
7395                         }
7396                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7397                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7398                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7399                 }
7400         }
7401         return NDR_ERR_SUCCESS;
7402 }
7403
7404 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo2 *r)
7405 {
7406         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo2");
7407         ndr->depth++;
7408         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7409         ndr->depth++;
7410         if (r->netbios_name) {
7411                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7412         }
7413         ndr->depth--;
7414         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7415         ndr->depth++;
7416         if (r->dns_name) {
7417                 ndr_print_string(ndr, "dns_name", r->dns_name);
7418         }
7419         ndr->depth--;
7420         ndr_print_ptr(ndr, "site_name", r->site_name);
7421         ndr->depth++;
7422         if (r->site_name) {
7423                 ndr_print_string(ndr, "site_name", r->site_name);
7424         }
7425         ndr->depth--;
7426         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7427         ndr->depth++;
7428         if (r->site_dn) {
7429                 ndr_print_string(ndr, "site_dn", r->site_dn);
7430         }
7431         ndr->depth--;
7432         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7433         ndr->depth++;
7434         if (r->computer_dn) {
7435                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7436         }
7437         ndr->depth--;
7438         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7439         ndr->depth++;
7440         if (r->server_dn) {
7441                 ndr_print_string(ndr, "server_dn", r->server_dn);
7442         }
7443         ndr->depth--;
7444         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7445         ndr->depth++;
7446         if (r->ntds_dn) {
7447                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7448         }
7449         ndr->depth--;
7450         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7451         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7452         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7453         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7454         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7455         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7456         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7457         ndr->depth--;
7458 }
7459
7460 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr2 *r)
7461 {
7462         uint32_t cntr_array_1;
7463         if (ndr_flags & NDR_SCALARS) {
7464                 NDR_CHECK(ndr_push_align(ndr, 5));
7465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7466                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7467                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7468         }
7469         if (ndr_flags & NDR_BUFFERS) {
7470                 if (r->array) {
7471                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7472                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7473                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7474                         }
7475                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7476                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7477                         }
7478                 }
7479         }
7480         return NDR_ERR_SUCCESS;
7481 }
7482
7483 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr2 *r)
7484 {
7485         uint32_t _ptr_array;
7486         uint32_t cntr_array_1;
7487         TALLOC_CTX *_mem_save_array_0;
7488         TALLOC_CTX *_mem_save_array_1;
7489         if (ndr_flags & NDR_SCALARS) {
7490                 NDR_CHECK(ndr_pull_align(ndr, 5));
7491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7492                 if (r->count > 10000) {
7493                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7494                 }
7495                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7496                 if (_ptr_array) {
7497                         NDR_PULL_ALLOC(ndr, r->array);
7498                 } else {
7499                         r->array = NULL;
7500                 }
7501                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7502         }
7503         if (ndr_flags & NDR_BUFFERS) {
7504                 if (r->array) {
7505                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7506                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7507                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7508                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7509                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7510                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7511                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7512                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7513                         }
7514                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7515                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7516                         }
7517                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7518                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7519                 }
7520                 if (r->array) {
7521                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7522                 }
7523         }
7524         return NDR_ERR_SUCCESS;
7525 }
7526
7527 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr2 *r)
7528 {
7529         uint32_t cntr_array_1;
7530         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr2");
7531         ndr->depth++;
7532         ndr_print_uint32(ndr, "count", r->count);
7533         ndr_print_ptr(ndr, "array", r->array);
7534         ndr->depth++;
7535         if (r->array) {
7536                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7537                 ndr->depth++;
7538                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7539                         char *idx_1=NULL;
7540                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7541                                 ndr_print_drsuapi_DsGetDCInfo2(ndr, "array", &r->array[cntr_array_1]);
7542                                 free(idx_1);
7543                         }
7544                 }
7545                 ndr->depth--;
7546         }
7547         ndr->depth--;
7548         ndr->depth--;
7549 }
7550
7551 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo3 *r)
7552 {
7553         if (ndr_flags & NDR_SCALARS) {
7554                 NDR_CHECK(ndr_push_align(ndr, 5));
7555                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7556                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7557                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7558                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7559                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7560                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7561                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7562                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_rodc));
7566                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7567                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7568                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7569                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7570                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7571         }
7572         if (ndr_flags & NDR_BUFFERS) {
7573                 if (r->netbios_name) {
7574                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7575                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7576                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7577                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7578                 }
7579                 if (r->dns_name) {
7580                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7581                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7582                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7583                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7584                 }
7585                 if (r->site_name) {
7586                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7587                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7588                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7589                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7590                 }
7591                 if (r->site_dn) {
7592                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7593                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7594                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7595                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7596                 }
7597                 if (r->computer_dn) {
7598                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7599                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7600                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7601                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7602                 }
7603                 if (r->server_dn) {
7604                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7605                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7606                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7607                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7608                 }
7609                 if (r->ntds_dn) {
7610                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7611                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7612                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7613                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7614                 }
7615         }
7616         return NDR_ERR_SUCCESS;
7617 }
7618
7619 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo3 *r)
7620 {
7621         uint32_t _ptr_netbios_name;
7622         TALLOC_CTX *_mem_save_netbios_name_0;
7623         uint32_t _ptr_dns_name;
7624         TALLOC_CTX *_mem_save_dns_name_0;
7625         uint32_t _ptr_site_name;
7626         TALLOC_CTX *_mem_save_site_name_0;
7627         uint32_t _ptr_site_dn;
7628         TALLOC_CTX *_mem_save_site_dn_0;
7629         uint32_t _ptr_computer_dn;
7630         TALLOC_CTX *_mem_save_computer_dn_0;
7631         uint32_t _ptr_server_dn;
7632         TALLOC_CTX *_mem_save_server_dn_0;
7633         uint32_t _ptr_ntds_dn;
7634         TALLOC_CTX *_mem_save_ntds_dn_0;
7635         if (ndr_flags & NDR_SCALARS) {
7636                 NDR_CHECK(ndr_pull_align(ndr, 5));
7637                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7638                 if (_ptr_netbios_name) {
7639                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7640                 } else {
7641                         r->netbios_name = NULL;
7642                 }
7643                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7644                 if (_ptr_dns_name) {
7645                         NDR_PULL_ALLOC(ndr, r->dns_name);
7646                 } else {
7647                         r->dns_name = NULL;
7648                 }
7649                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7650                 if (_ptr_site_name) {
7651                         NDR_PULL_ALLOC(ndr, r->site_name);
7652                 } else {
7653                         r->site_name = NULL;
7654                 }
7655                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7656                 if (_ptr_site_dn) {
7657                         NDR_PULL_ALLOC(ndr, r->site_dn);
7658                 } else {
7659                         r->site_dn = NULL;
7660                 }
7661                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7662                 if (_ptr_computer_dn) {
7663                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7664                 } else {
7665                         r->computer_dn = NULL;
7666                 }
7667                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7668                 if (_ptr_server_dn) {
7669                         NDR_PULL_ALLOC(ndr, r->server_dn);
7670                 } else {
7671                         r->server_dn = NULL;
7672                 }
7673                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7674                 if (_ptr_ntds_dn) {
7675                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7676                 } else {
7677                         r->ntds_dn = NULL;
7678                 }
7679                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7681                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_rodc));
7683                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7684                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7685                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7686                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7687                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7688         }
7689         if (ndr_flags & NDR_BUFFERS) {
7690                 if (r->netbios_name) {
7691                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7692                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7693                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7694                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7695                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7696                                 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));
7697                         }
7698                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7699                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7700                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7701                 }
7702                 if (r->dns_name) {
7703                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7704                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7705                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7706                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7707                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7708                                 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));
7709                         }
7710                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7711                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7712                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7713                 }
7714                 if (r->site_name) {
7715                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7716                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7717                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7718                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7719                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7720                                 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));
7721                         }
7722                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7723                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7724                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7725                 }
7726                 if (r->site_dn) {
7727                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7728                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7729                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7730                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7731                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7732                                 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));
7733                         }
7734                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7735                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7736                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7737                 }
7738                 if (r->computer_dn) {
7739                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7740                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7741                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7742                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7743                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7744                                 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));
7745                         }
7746                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7747                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7749                 }
7750                 if (r->server_dn) {
7751                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7752                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7753                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7754                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7755                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7756                                 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));
7757                         }
7758                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7759                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7761                 }
7762                 if (r->ntds_dn) {
7763                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7764                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7765                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7766                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7767                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7768                                 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));
7769                         }
7770                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7771                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7772                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7773                 }
7774         }
7775         return NDR_ERR_SUCCESS;
7776 }
7777
7778 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo3 *r)
7779 {
7780         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo3");
7781         ndr->depth++;
7782         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7783         ndr->depth++;
7784         if (r->netbios_name) {
7785                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7786         }
7787         ndr->depth--;
7788         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7789         ndr->depth++;
7790         if (r->dns_name) {
7791                 ndr_print_string(ndr, "dns_name", r->dns_name);
7792         }
7793         ndr->depth--;
7794         ndr_print_ptr(ndr, "site_name", r->site_name);
7795         ndr->depth++;
7796         if (r->site_name) {
7797                 ndr_print_string(ndr, "site_name", r->site_name);
7798         }
7799         ndr->depth--;
7800         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7801         ndr->depth++;
7802         if (r->site_dn) {
7803                 ndr_print_string(ndr, "site_dn", r->site_dn);
7804         }
7805         ndr->depth--;
7806         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7807         ndr->depth++;
7808         if (r->computer_dn) {
7809                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7810         }
7811         ndr->depth--;
7812         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7813         ndr->depth++;
7814         if (r->server_dn) {
7815                 ndr_print_string(ndr, "server_dn", r->server_dn);
7816         }
7817         ndr->depth--;
7818         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7819         ndr->depth++;
7820         if (r->ntds_dn) {
7821                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7822         }
7823         ndr->depth--;
7824         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7825         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7826         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7827         ndr_print_uint32(ndr, "is_rodc", r->is_rodc);
7828         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7829         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7830         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7831         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7832         ndr->depth--;
7833 }
7834
7835 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr3 *r)
7836 {
7837         uint32_t cntr_array_1;
7838         if (ndr_flags & NDR_SCALARS) {
7839                 NDR_CHECK(ndr_push_align(ndr, 5));
7840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7841                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7842                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7843         }
7844         if (ndr_flags & NDR_BUFFERS) {
7845                 if (r->array) {
7846                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7847                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7848                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7849                         }
7850                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7851                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7852                         }
7853                 }
7854         }
7855         return NDR_ERR_SUCCESS;
7856 }
7857
7858 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr3 *r)
7859 {
7860         uint32_t _ptr_array;
7861         uint32_t cntr_array_1;
7862         TALLOC_CTX *_mem_save_array_0;
7863         TALLOC_CTX *_mem_save_array_1;
7864         if (ndr_flags & NDR_SCALARS) {
7865                 NDR_CHECK(ndr_pull_align(ndr, 5));
7866                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7867                 if (r->count > 10000) {
7868                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7869                 }
7870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7871                 if (_ptr_array) {
7872                         NDR_PULL_ALLOC(ndr, r->array);
7873                 } else {
7874                         r->array = NULL;
7875                 }
7876                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7877         }
7878         if (ndr_flags & NDR_BUFFERS) {
7879                 if (r->array) {
7880                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7881                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7882                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7883                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7884                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7885                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7886                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7887                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7888                         }
7889                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7890                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7891                         }
7892                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7893                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7894                 }
7895                 if (r->array) {
7896                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7897                 }
7898         }
7899         return NDR_ERR_SUCCESS;
7900 }
7901
7902 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr3 *r)
7903 {
7904         uint32_t cntr_array_1;
7905         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr3");
7906         ndr->depth++;
7907         ndr_print_uint32(ndr, "count", r->count);
7908         ndr_print_ptr(ndr, "array", r->array);
7909         ndr->depth++;
7910         if (r->array) {
7911                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7912                 ndr->depth++;
7913                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7914                         char *idx_1=NULL;
7915                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7916                                 ndr_print_drsuapi_DsGetDCInfo3(ndr, "array", &r->array[cntr_array_1]);
7917                                 free(idx_1);
7918                         }
7919                 }
7920                 ndr->depth--;
7921         }
7922         ndr->depth--;
7923         ndr->depth--;
7924 }
7925
7926 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnection01 *r)
7927 {
7928         if (ndr_flags & NDR_SCALARS) {
7929                 NDR_CHECK(ndr_push_align(ndr, 5));
7930                 {
7931                         uint32_t _flags_save_ipv4address = ndr->flags;
7932                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
7933                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
7934                         ndr->flags = _flags_save_ipv4address;
7935                 }
7936                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
7937                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connection_time));
7938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
7939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
7940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
7941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
7942                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7943         }
7944         if (ndr_flags & NDR_BUFFERS) {
7945                 if (r->client_account) {
7946                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7947                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7948                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7949                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_account, ndr_charset_length(r->client_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7950                 }
7951         }
7952         return NDR_ERR_SUCCESS;
7953 }
7954
7955 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnection01 *r)
7956 {
7957         uint32_t _ptr_client_account;
7958         TALLOC_CTX *_mem_save_client_account_0;
7959         if (ndr_flags & NDR_SCALARS) {
7960                 NDR_CHECK(ndr_pull_align(ndr, 5));
7961                 {
7962                         uint32_t _flags_save_ipv4address = ndr->flags;
7963                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
7964                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
7965                         ndr->flags = _flags_save_ipv4address;
7966                 }
7967                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
7968                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connection_time));
7969                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
7970                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
7971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
7972                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_account));
7973                 if (_ptr_client_account) {
7974                         NDR_PULL_ALLOC(ndr, r->client_account);
7975                 } else {
7976                         r->client_account = NULL;
7977                 }
7978                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7979         }
7980         if (ndr_flags & NDR_BUFFERS) {
7981                 if (r->client_account) {
7982                         _mem_save_client_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
7983                         NDR_PULL_SET_MEM_CTX(ndr, r->client_account, 0);
7984                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_account));
7985                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_account));
7986                         if (ndr_get_array_length(ndr, &r->client_account) > ndr_get_array_size(ndr, &r->client_account)) {
7987                                 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));
7988                         }
7989                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t)));
7990                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t), CH_UTF16));
7991                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_account_0, 0);
7992                 }
7993         }
7994         return NDR_ERR_SUCCESS;
7995 }
7996
7997 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnection01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnection01 *r)
7998 {
7999         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnection01");
8000         ndr->depth++;
8001         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
8002         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8003         ndr_print_uint32(ndr, "connection_time", r->connection_time);
8004         ndr_print_uint32(ndr, "unknown4", r->unknown4);
8005         ndr_print_uint32(ndr, "unknown5", r->unknown5);
8006         ndr_print_uint32(ndr, "unknown6", r->unknown6);
8007         ndr_print_ptr(ndr, "client_account", r->client_account);
8008         ndr->depth++;
8009         if (r->client_account) {
8010                 ndr_print_string(ndr, "client_account", r->client_account);
8011         }
8012         ndr->depth--;
8013         ndr->depth--;
8014 }
8015
8016 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8017 {
8018         uint32_t cntr_array_1;
8019         if (ndr_flags & NDR_SCALARS) {
8020                 NDR_CHECK(ndr_push_align(ndr, 5));
8021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8022                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
8023                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8024         }
8025         if (ndr_flags & NDR_BUFFERS) {
8026                 if (r->array) {
8027                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
8028                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8029                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8030                         }
8031                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8032                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8033                         }
8034                 }
8035         }
8036         return NDR_ERR_SUCCESS;
8037 }
8038
8039 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnectionCtr01 *r)
8040 {
8041         uint32_t _ptr_array;
8042         uint32_t cntr_array_1;
8043         TALLOC_CTX *_mem_save_array_0;
8044         TALLOC_CTX *_mem_save_array_1;
8045         if (ndr_flags & NDR_SCALARS) {
8046                 NDR_CHECK(ndr_pull_align(ndr, 5));
8047                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8048                 if (r->count > 10000) {
8049                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8050                 }
8051                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
8052                 if (_ptr_array) {
8053                         NDR_PULL_ALLOC(ndr, r->array);
8054                 } else {
8055                         r->array = NULL;
8056                 }
8057                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8058         }
8059         if (ndr_flags & NDR_BUFFERS) {
8060                 if (r->array) {
8061                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
8062                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8063                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
8064                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
8065                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
8066                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8067                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8068                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8069                         }
8070                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8071                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8072                         }
8073                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
8074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
8075                 }
8076                 if (r->array) {
8077                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
8078                 }
8079         }
8080         return NDR_ERR_SUCCESS;
8081 }
8082
8083 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnectionCtr01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8084 {
8085         uint32_t cntr_array_1;
8086         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnectionCtr01");
8087         ndr->depth++;
8088         ndr_print_uint32(ndr, "count", r->count);
8089         ndr_print_ptr(ndr, "array", r->array);
8090         ndr->depth++;
8091         if (r->array) {
8092                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
8093                 ndr->depth++;
8094                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
8095                         char *idx_1=NULL;
8096                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8097                                 ndr_print_drsuapi_DsGetDCConnection01(ndr, "array", &r->array[cntr_array_1]);
8098                                 free(idx_1);
8099                         }
8100                 }
8101                 ndr->depth--;
8102         }
8103         ndr->depth--;
8104         ndr->depth--;
8105 }
8106
8107 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoCtr *r)
8108 {
8109         if (ndr_flags & NDR_SCALARS) {
8110                 int level = ndr_push_get_switch_value(ndr, r);
8111                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8112                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8113                 switch (level) {
8114                         case DRSUAPI_DC_INFO_CTR_1: {
8115                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8116                         break; }
8117
8118                         case DRSUAPI_DC_INFO_CTR_2: {
8119                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8120                         break; }
8121
8122                         case DRSUAPI_DC_INFO_CTR_3: {
8123                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8124                         break; }
8125
8126                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8127                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8128                         break; }
8129
8130                         default:
8131                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8132                 }
8133         }
8134         if (ndr_flags & NDR_BUFFERS) {
8135                 int level = ndr_push_get_switch_value(ndr, r);
8136                 switch (level) {
8137                         case DRSUAPI_DC_INFO_CTR_1:
8138                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8139                         break;
8140
8141                         case DRSUAPI_DC_INFO_CTR_2:
8142                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8143                         break;
8144
8145                         case DRSUAPI_DC_INFO_CTR_3:
8146                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8147                         break;
8148
8149                         case DRSUAPI_DC_CONNECTION_CTR_01:
8150                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &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         return NDR_ERR_SUCCESS;
8158 }
8159
8160 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoCtr *r)
8161 {
8162         int level;
8163         int32_t _level;
8164         level = ndr_pull_get_switch_value(ndr, r);
8165         if (ndr_flags & NDR_SCALARS) {
8166                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8167                 if (_level != level) {
8168                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8169                 }
8170                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8171                 switch (level) {
8172                         case DRSUAPI_DC_INFO_CTR_1: {
8173                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8174                         break; }
8175
8176                         case DRSUAPI_DC_INFO_CTR_2: {
8177                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8178                         break; }
8179
8180                         case DRSUAPI_DC_INFO_CTR_3: {
8181                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8182                         break; }
8183
8184                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8185                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8186                         break; }
8187
8188                         default:
8189                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8190                 }
8191         }
8192         if (ndr_flags & NDR_BUFFERS) {
8193                 switch (level) {
8194                         case DRSUAPI_DC_INFO_CTR_1:
8195                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8196                         break;
8197
8198                         case DRSUAPI_DC_INFO_CTR_2:
8199                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8200                         break;
8201
8202                         case DRSUAPI_DC_INFO_CTR_3:
8203                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8204                         break;
8205
8206                         case DRSUAPI_DC_CONNECTION_CTR_01:
8207                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8208                         break;
8209
8210                         default:
8211                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8212                 }
8213         }
8214         return NDR_ERR_SUCCESS;
8215 }
8216
8217 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoCtr *r)
8218 {
8219         int level;
8220         level = ndr_print_get_switch_value(ndr, r);
8221         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoCtr");
8222         switch (level) {
8223                 case DRSUAPI_DC_INFO_CTR_1:
8224                         ndr_print_drsuapi_DsGetDCInfoCtr1(ndr, "ctr1", &r->ctr1);
8225                 break;
8226
8227                 case DRSUAPI_DC_INFO_CTR_2:
8228                         ndr_print_drsuapi_DsGetDCInfoCtr2(ndr, "ctr2", &r->ctr2);
8229                 break;
8230
8231                 case DRSUAPI_DC_INFO_CTR_3:
8232                         ndr_print_drsuapi_DsGetDCInfoCtr3(ndr, "ctr3", &r->ctr3);
8233                 break;
8234
8235                 case DRSUAPI_DC_CONNECTION_CTR_01:
8236                         ndr_print_drsuapi_DsGetDCConnectionCtr01(ndr, "ctr01", &r->ctr01);
8237                 break;
8238
8239                 default:
8240                         ndr_print_bad_level(ndr, name, level);
8241         }
8242 }
8243
8244 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItem *r)
8245 {
8246         if (ndr_flags & NDR_SCALARS) {
8247                 NDR_CHECK(ndr_push_align(ndr, 5));
8248                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
8249                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8250                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8251         }
8252         if (ndr_flags & NDR_BUFFERS) {
8253                 if (r->next_object) {
8254                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8255                 }
8256                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8257         }
8258         return NDR_ERR_SUCCESS;
8259 }
8260
8261 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItem *r)
8262 {
8263         uint32_t _ptr_next_object;
8264         TALLOC_CTX *_mem_save_next_object_0;
8265         if (ndr_flags & NDR_SCALARS) {
8266                 NDR_CHECK(ndr_pull_align(ndr, 5));
8267                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
8268                 if (_ptr_next_object) {
8269                         NDR_PULL_ALLOC(ndr, r->next_object);
8270                 } else {
8271                         r->next_object = NULL;
8272                 }
8273                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8274                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8275         }
8276         if (ndr_flags & NDR_BUFFERS) {
8277                 if (r->next_object) {
8278                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
8279                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
8280                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8281                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
8282                 }
8283                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8284         }
8285         return NDR_ERR_SUCCESS;
8286 }
8287
8288 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryRequest2 *r)
8289 {
8290         if (ndr_flags & NDR_SCALARS) {
8291                 NDR_CHECK(ndr_push_align(ndr, 5));
8292                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8293                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8294         }
8295         if (ndr_flags & NDR_BUFFERS) {
8296                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8297         }
8298         return NDR_ERR_SUCCESS;
8299 }
8300
8301 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryRequest2 *r)
8302 {
8303         if (ndr_flags & NDR_SCALARS) {
8304                 NDR_CHECK(ndr_pull_align(ndr, 5));
8305                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8306                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8307         }
8308         if (ndr_flags & NDR_BUFFERS) {
8309                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8310         }
8311         return NDR_ERR_SUCCESS;
8312 }
8313
8314 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryRequest2 *r)
8315 {
8316         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryRequest2");
8317         ndr->depth++;
8318         ndr_print_drsuapi_DsReplicaObjectListItem(ndr, "first_object", &r->first_object);
8319         ndr->depth--;
8320 }
8321
8322 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryRequest *r)
8323 {
8324         if (ndr_flags & NDR_SCALARS) {
8325                 int level = ndr_push_get_switch_value(ndr, r);
8326                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8327                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8328                 switch (level) {
8329                         case 2: {
8330                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8331                         break; }
8332
8333                         default:
8334                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8335                 }
8336         }
8337         if (ndr_flags & NDR_BUFFERS) {
8338                 int level = ndr_push_get_switch_value(ndr, r);
8339                 switch (level) {
8340                         case 2:
8341                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8342                         break;
8343
8344                         default:
8345                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8346                 }
8347         }
8348         return NDR_ERR_SUCCESS;
8349 }
8350
8351 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryRequest *r)
8352 {
8353         int level;
8354         int32_t _level;
8355         level = ndr_pull_get_switch_value(ndr, r);
8356         if (ndr_flags & NDR_SCALARS) {
8357                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8358                 if (_level != level) {
8359                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8360                 }
8361                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8362                 switch (level) {
8363                         case 2: {
8364                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8365                         break; }
8366
8367                         default:
8368                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8369                 }
8370         }
8371         if (ndr_flags & NDR_BUFFERS) {
8372                 switch (level) {
8373                         case 2:
8374                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8375                         break;
8376
8377                         default:
8378                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8379                 }
8380         }
8381         return NDR_ERR_SUCCESS;
8382 }
8383
8384 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryRequest *r)
8385 {
8386         int level;
8387         level = ndr_print_get_switch_value(ndr, r);
8388         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryRequest");
8389         switch (level) {
8390                 case 2:
8391                         ndr_print_drsuapi_DsAddEntryRequest2(ndr, "req2", &r->req2);
8392                 break;
8393
8394                 default:
8395                         ndr_print_bad_level(ndr, name, level);
8396         }
8397 }
8398
8399 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfoX *r)
8400 {
8401         if (ndr_flags & NDR_SCALARS) {
8402                 NDR_CHECK(ndr_push_align(ndr, 4));
8403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8404                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8406                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
8407                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8408         }
8409         if (ndr_flags & NDR_BUFFERS) {
8410         }
8411         return NDR_ERR_SUCCESS;
8412 }
8413
8414 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfoX *r)
8415 {
8416         if (ndr_flags & NDR_SCALARS) {
8417                 NDR_CHECK(ndr_pull_align(ndr, 4));
8418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8419                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8421                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
8422                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8423         }
8424         if (ndr_flags & NDR_BUFFERS) {
8425         }
8426         return NDR_ERR_SUCCESS;
8427 }
8428
8429 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfoX(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfoX *r)
8430 {
8431         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfoX");
8432         ndr->depth++;
8433         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8434         ndr_print_WERROR(ndr, "status", r->status);
8435         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8436         ndr_print_uint16(ndr, "unknown3", r->unknown3);
8437         ndr->depth--;
8438 }
8439
8440 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8441 {
8442         if (ndr_flags & NDR_SCALARS) {
8443                 NDR_CHECK(ndr_push_align(ndr, 5));
8444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8445                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
8446                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8447         }
8448         if (ndr_flags & NDR_BUFFERS) {
8449                 if (r->data) {
8450                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size));
8451                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
8452                 }
8453         }
8454         return NDR_ERR_SUCCESS;
8455 }
8456
8457 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8458 {
8459         uint32_t _ptr_data;
8460         TALLOC_CTX *_mem_save_data_0;
8461         if (ndr_flags & NDR_SCALARS) {
8462                 NDR_CHECK(ndr_pull_align(ndr, 5));
8463                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8464                 if (r->size > 10485760) {
8465                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8466                 }
8467                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
8468                 if (_ptr_data) {
8469                         NDR_PULL_ALLOC(ndr, r->data);
8470                 } else {
8471                         r->data = NULL;
8472                 }
8473                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8474         }
8475         if (ndr_flags & NDR_BUFFERS) {
8476                 if (r->data) {
8477                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
8478                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
8479                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
8480                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
8481                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
8482                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
8483                 }
8484                 if (r->data) {
8485                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
8486                 }
8487         }
8488         return NDR_ERR_SUCCESS;
8489 }
8490
8491 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8492 {
8493         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraErrorBuffer");
8494         ndr->depth++;
8495         ndr_print_uint32(ndr, "size", r->size);
8496         ndr_print_ptr(ndr, "data", r->data);
8497         ndr->depth++;
8498         if (r->data) {
8499                 ndr_print_array_uint8(ndr, "data", r->data, r->size);
8500         }
8501         ndr->depth--;
8502         ndr->depth--;
8503 }
8504
8505 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraError1 *r)
8506 {
8507         if (ndr_flags & NDR_SCALARS) {
8508                 NDR_CHECK(ndr_push_align(ndr, 5));
8509                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8510                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
8511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8512                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8513                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8514         }
8515         if (ndr_flags & NDR_BUFFERS) {
8516                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8517         }
8518         return NDR_ERR_SUCCESS;
8519 }
8520
8521 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraError1 *r)
8522 {
8523         if (ndr_flags & NDR_SCALARS) {
8524                 NDR_CHECK(ndr_pull_align(ndr, 5));
8525                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8526                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
8527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8528                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8529                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8530         }
8531         if (ndr_flags & NDR_BUFFERS) {
8532                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8533         }
8534         return NDR_ERR_SUCCESS;
8535 }
8536
8537 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraError1 *r)
8538 {
8539         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraError1");
8540         ndr->depth++;
8541         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8542         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
8543         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8544         ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(ndr, "buffer", &r->buffer);
8545         ndr->depth--;
8546 }
8547
8548 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8549 {
8550         if (ndr_flags & NDR_SCALARS) {
8551                 NDR_CHECK(ndr_push_align(ndr, 5));
8552                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
8553                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8554                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8555         }
8556         if (ndr_flags & NDR_BUFFERS) {
8557                 if (r->next) {
8558                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8559                 }
8560                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8561         }
8562         return NDR_ERR_SUCCESS;
8563 }
8564
8565 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorListItem1 *r)
8566 {
8567         uint32_t _ptr_next;
8568         TALLOC_CTX *_mem_save_next_0;
8569         if (ndr_flags & NDR_SCALARS) {
8570                 NDR_CHECK(ndr_pull_align(ndr, 5));
8571                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
8572                 if (_ptr_next) {
8573                         NDR_PULL_ALLOC(ndr, r->next);
8574                 } else {
8575                         r->next = NULL;
8576                 }
8577                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8578                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8579         }
8580         if (ndr_flags & NDR_BUFFERS) {
8581                 if (r->next) {
8582                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
8583                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
8584                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8585                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
8586                 }
8587                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8588         }
8589         return NDR_ERR_SUCCESS;
8590 }
8591
8592 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorListItem1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8593 {
8594         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorListItem1");
8595         ndr->depth++;
8596         ndr_print_ptr(ndr, "next", r->next);
8597         ndr->depth++;
8598         if (r->next) {
8599                 ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "next", r->next);
8600         }
8601         ndr->depth--;
8602         ndr_print_drsuapi_DsAddEntryExtraError1(ndr, "error", &r->error);
8603         ndr->depth--;
8604 }
8605
8606 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8607 {
8608         if (ndr_flags & NDR_SCALARS) {
8609                 NDR_CHECK(ndr_push_align(ndr, 5));
8610                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8611                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8612                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8613                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8614         }
8615         if (ndr_flags & NDR_BUFFERS) {
8616                 if (r->id) {
8617                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8618                 }
8619                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8620         }
8621         return NDR_ERR_SUCCESS;
8622 }
8623
8624 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfo1 *r)
8625 {
8626         uint32_t _ptr_id;
8627         TALLOC_CTX *_mem_save_id_0;
8628         if (ndr_flags & NDR_SCALARS) {
8629                 NDR_CHECK(ndr_pull_align(ndr, 5));
8630                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8631                 if (_ptr_id) {
8632                         NDR_PULL_ALLOC(ndr, r->id);
8633                 } else {
8634                         r->id = NULL;
8635                 }
8636                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8637                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8638                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8639         }
8640         if (ndr_flags & NDR_BUFFERS) {
8641                 if (r->id) {
8642                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8643                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8644                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8645                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8646                 }
8647                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8648         }
8649         return NDR_ERR_SUCCESS;
8650 }
8651
8652 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8653 {
8654         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfo1");
8655         ndr->depth++;
8656         ndr_print_ptr(ndr, "id", r->id);
8657         ndr->depth++;
8658         if (r->id) {
8659                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8660         }
8661         ndr->depth--;
8662         ndr_print_WERROR(ndr, "status", r->status);
8663         ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "first", &r->first);
8664         ndr->depth--;
8665 }
8666
8667 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryErrorInfo *r)
8668 {
8669         if (ndr_flags & NDR_SCALARS) {
8670                 int level = ndr_push_get_switch_value(ndr, r);
8671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8672                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8673                 switch (level) {
8674                         case 1: {
8675                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8676                         break; }
8677
8678                         case 4: {
8679                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8680                         break; }
8681
8682                         case 5: {
8683                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8684                         break; }
8685
8686                         case 6: {
8687                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8688                         break; }
8689
8690                         case 7: {
8691                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8692                         break; }
8693
8694                         default:
8695                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8696                 }
8697         }
8698         if (ndr_flags & NDR_BUFFERS) {
8699                 int level = ndr_push_get_switch_value(ndr, r);
8700                 switch (level) {
8701                         case 1:
8702                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8703                         break;
8704
8705                         case 4:
8706                         break;
8707
8708                         case 5:
8709                         break;
8710
8711                         case 6:
8712                         break;
8713
8714                         case 7:
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         return NDR_ERR_SUCCESS;
8722 }
8723
8724 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryErrorInfo *r)
8725 {
8726         int level;
8727         uint32_t _level;
8728         level = ndr_pull_get_switch_value(ndr, r);
8729         if (ndr_flags & NDR_SCALARS) {
8730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8731                 if (_level != level) {
8732                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8733                 }
8734                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8735                 switch (level) {
8736                         case 1: {
8737                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8738                         break; }
8739
8740                         case 4: {
8741                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8742                         break; }
8743
8744                         case 5: {
8745                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8746                         break; }
8747
8748                         case 6: {
8749                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8750                         break; }
8751
8752                         case 7: {
8753                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8754                         break; }
8755
8756                         default:
8757                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8758                 }
8759         }
8760         if (ndr_flags & NDR_BUFFERS) {
8761                 switch (level) {
8762                         case 1:
8763                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8764                         break;
8765
8766                         case 4:
8767                         break;
8768
8769                         case 5:
8770                         break;
8771
8772                         case 6:
8773                         break;
8774
8775                         case 7:
8776                         break;
8777
8778                         default:
8779                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8780                 }
8781         }
8782         return NDR_ERR_SUCCESS;
8783 }
8784
8785 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryErrorInfo *r)
8786 {
8787         int level;
8788         level = ndr_print_get_switch_value(ndr, r);
8789         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryErrorInfo");
8790         switch (level) {
8791                 case 1:
8792                         ndr_print_drsuapi_DsAddEntryErrorInfo1(ndr, "error1", &r->error1);
8793                 break;
8794
8795                 case 4:
8796                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8797                 break;
8798
8799                 case 5:
8800                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8801                 break;
8802
8803                 case 6:
8804                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8805                 break;
8806
8807                 case 7:
8808                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8809                 break;
8810
8811                 default:
8812                         ndr_print_bad_level(ndr, name, level);
8813         }
8814 }
8815
8816 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryError1 *r)
8817 {
8818         if (ndr_flags & NDR_SCALARS) {
8819                 NDR_CHECK(ndr_push_align(ndr, 5));
8820                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8822                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
8823                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8824         }
8825         if (ndr_flags & NDR_BUFFERS) {
8826                 if (r->info) {
8827                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->info, r->level));
8828                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8829                 }
8830         }
8831         return NDR_ERR_SUCCESS;
8832 }
8833
8834 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryError1 *r)
8835 {
8836         uint32_t _ptr_info;
8837         TALLOC_CTX *_mem_save_info_0;
8838         if (ndr_flags & NDR_SCALARS) {
8839                 NDR_CHECK(ndr_pull_align(ndr, 5));
8840                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8843                 if (_ptr_info) {
8844                         NDR_PULL_ALLOC(ndr, r->info);
8845                 } else {
8846                         r->info = NULL;
8847                 }
8848                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8849         }
8850         if (ndr_flags & NDR_BUFFERS) {
8851                 if (r->info) {
8852                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8853                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
8854                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->info, r->level));
8855                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8856                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8857                 }
8858         }
8859         return NDR_ERR_SUCCESS;
8860 }
8861
8862 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryError1 *r)
8863 {
8864         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryError1");
8865         ndr->depth++;
8866         ndr_print_WERROR(ndr, "status", r->status);
8867         ndr_print_uint32(ndr, "level", r->level);
8868         ndr_print_ptr(ndr, "info", r->info);
8869         ndr->depth++;
8870         if (r->info) {
8871                 ndr_print_set_switch_value(ndr, r->info, r->level);
8872                 ndr_print_drsuapi_DsAddEntryErrorInfo(ndr, "info", r->info);
8873         }
8874         ndr->depth--;
8875         ndr->depth--;
8876 }
8877
8878 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryError *r)
8879 {
8880         if (ndr_flags & NDR_SCALARS) {
8881                 int level = ndr_push_get_switch_value(ndr, r);
8882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8883                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8884                 switch (level) {
8885                         case 1: {
8886                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8887                         break; }
8888
8889                         default:
8890                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8891                 }
8892         }
8893         if (ndr_flags & NDR_BUFFERS) {
8894                 int level = ndr_push_get_switch_value(ndr, r);
8895                 switch (level) {
8896                         case 1:
8897                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8898                         break;
8899
8900                         default:
8901                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8902                 }
8903         }
8904         return NDR_ERR_SUCCESS;
8905 }
8906
8907 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryError *r)
8908 {
8909         int level;
8910         uint32_t _level;
8911         level = ndr_pull_get_switch_value(ndr, r);
8912         if (ndr_flags & NDR_SCALARS) {
8913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8914                 if (_level != level) {
8915                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8916                 }
8917                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8918                 switch (level) {
8919                         case 1: {
8920                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8921                         break; }
8922
8923                         default:
8924                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8925                 }
8926         }
8927         if (ndr_flags & NDR_BUFFERS) {
8928                 switch (level) {
8929                         case 1:
8930                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8931                         break;
8932
8933                         default:
8934                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8935                 }
8936         }
8937         return NDR_ERR_SUCCESS;
8938 }
8939
8940 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryError *r)
8941 {
8942         int level;
8943         level = ndr_print_get_switch_value(ndr, r);
8944         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryError");
8945         switch (level) {
8946                 case 1:
8947                         ndr_print_drsuapi_DsAddEntryError1(ndr, "info1", &r->info1);
8948                 break;
8949
8950                 default:
8951                         ndr_print_bad_level(ndr, name, level);
8952         }
8953 }
8954
8955 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
8956 {
8957         if (ndr_flags & NDR_SCALARS) {
8958                 NDR_CHECK(ndr_push_align(ndr, 4));
8959                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
8960                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
8961                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8962         }
8963         if (ndr_flags & NDR_BUFFERS) {
8964                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
8965         }
8966         return NDR_ERR_SUCCESS;
8967 }
8968
8969 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier2 *r)
8970 {
8971         if (ndr_flags & NDR_SCALARS) {
8972                 NDR_CHECK(ndr_pull_align(ndr, 4));
8973                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
8974                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
8975                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8976         }
8977         if (ndr_flags & NDR_BUFFERS) {
8978                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
8979         }
8980         return NDR_ERR_SUCCESS;
8981 }
8982
8983 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
8984 {
8985         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier2");
8986         ndr->depth++;
8987         ndr_print_GUID(ndr, "guid", &r->guid);
8988         ndr_print_dom_sid28(ndr, "sid", &r->sid);
8989         ndr->depth--;
8990 }
8991
8992 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr2 *r)
8993 {
8994         uint32_t cntr_objects_1;
8995         if (ndr_flags & NDR_SCALARS) {
8996                 NDR_CHECK(ndr_push_align(ndr, 5));
8997                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8999                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9001                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9002                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9003         }
9004         if (ndr_flags & NDR_BUFFERS) {
9005                 if (r->id) {
9006                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9007                 }
9008                 if (r->objects) {
9009                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9010                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9011                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9012                         }
9013                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9014                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9015                         }
9016                 }
9017         }
9018         return NDR_ERR_SUCCESS;
9019 }
9020
9021 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr2 *r)
9022 {
9023         uint32_t _ptr_id;
9024         TALLOC_CTX *_mem_save_id_0;
9025         uint32_t _ptr_objects;
9026         uint32_t cntr_objects_1;
9027         TALLOC_CTX *_mem_save_objects_0;
9028         TALLOC_CTX *_mem_save_objects_1;
9029         if (ndr_flags & NDR_SCALARS) {
9030                 NDR_CHECK(ndr_pull_align(ndr, 5));
9031                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9032                 if (_ptr_id) {
9033                         NDR_PULL_ALLOC(ndr, r->id);
9034                 } else {
9035                         r->id = NULL;
9036                 }
9037                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9038                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9039                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9040                 if (r->count > 10000) {
9041                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9042                 }
9043                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9044                 if (_ptr_objects) {
9045                         NDR_PULL_ALLOC(ndr, r->objects);
9046                 } else {
9047                         r->objects = NULL;
9048                 }
9049                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9050         }
9051         if (ndr_flags & NDR_BUFFERS) {
9052                 if (r->id) {
9053                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9054                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9055                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9056                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9057                 }
9058                 if (r->objects) {
9059                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9060                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9061                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9062                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9063                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9064                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9065                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9066                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9067                         }
9068                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9069                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9070                         }
9071                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9072                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9073                 }
9074                 if (r->objects) {
9075                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9076                 }
9077         }
9078         return NDR_ERR_SUCCESS;
9079 }
9080
9081 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr2 *r)
9082 {
9083         uint32_t cntr_objects_1;
9084         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr2");
9085         ndr->depth++;
9086         ndr_print_ptr(ndr, "id", r->id);
9087         ndr->depth++;
9088         if (r->id) {
9089                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9090         }
9091         ndr->depth--;
9092         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9093         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
9094         ndr_print_uint32(ndr, "count", r->count);
9095         ndr_print_ptr(ndr, "objects", r->objects);
9096         ndr->depth++;
9097         if (r->objects) {
9098                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9099                 ndr->depth++;
9100                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9101                         char *idx_1=NULL;
9102                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9103                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9104                                 free(idx_1);
9105                         }
9106                 }
9107                 ndr->depth--;
9108         }
9109         ndr->depth--;
9110         ndr->depth--;
9111 }
9112
9113 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr3 *r)
9114 {
9115         uint32_t cntr_objects_1;
9116         if (ndr_flags & NDR_SCALARS) {
9117                 NDR_CHECK(ndr_push_align(ndr, 5));
9118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9120                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
9121                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9122                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9123                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9124         }
9125         if (ndr_flags & NDR_BUFFERS) {
9126                 if (r->id) {
9127                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9128                 }
9129                 if (r->error) {
9130                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->error, r->level));
9131                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9132                 }
9133                 if (r->objects) {
9134                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9135                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9136                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9137                         }
9138                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9139                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9140                         }
9141                 }
9142         }
9143         return NDR_ERR_SUCCESS;
9144 }
9145
9146 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr3 *r)
9147 {
9148         uint32_t _ptr_id;
9149         TALLOC_CTX *_mem_save_id_0;
9150         uint32_t _ptr_error;
9151         TALLOC_CTX *_mem_save_error_0;
9152         uint32_t _ptr_objects;
9153         uint32_t cntr_objects_1;
9154         TALLOC_CTX *_mem_save_objects_0;
9155         TALLOC_CTX *_mem_save_objects_1;
9156         if (ndr_flags & NDR_SCALARS) {
9157                 NDR_CHECK(ndr_pull_align(ndr, 5));
9158                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9159                 if (_ptr_id) {
9160                         NDR_PULL_ALLOC(ndr, r->id);
9161                 } else {
9162                         r->id = NULL;
9163                 }
9164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_error));
9166                 if (_ptr_error) {
9167                         NDR_PULL_ALLOC(ndr, r->error);
9168                 } else {
9169                         r->error = NULL;
9170                 }
9171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9172                 if (r->count > 10000) {
9173                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9174                 }
9175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9176                 if (_ptr_objects) {
9177                         NDR_PULL_ALLOC(ndr, r->objects);
9178                 } else {
9179                         r->objects = NULL;
9180                 }
9181                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9182         }
9183         if (ndr_flags & NDR_BUFFERS) {
9184                 if (r->id) {
9185                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9186                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9187                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9188                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9189                 }
9190                 if (r->error) {
9191                         _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
9192                         NDR_PULL_SET_MEM_CTX(ndr, r->error, 0);
9193                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->error, r->level));
9194                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9195                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, 0);
9196                 }
9197                 if (r->objects) {
9198                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9199                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9200                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9201                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9202                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9203                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9204                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9205                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9206                         }
9207                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9208                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9209                         }
9210                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9211                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9212                 }
9213                 if (r->objects) {
9214                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9215                 }
9216         }
9217         return NDR_ERR_SUCCESS;
9218 }
9219
9220 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr3 *r)
9221 {
9222         uint32_t cntr_objects_1;
9223         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr3");
9224         ndr->depth++;
9225         ndr_print_ptr(ndr, "id", r->id);
9226         ndr->depth++;
9227         if (r->id) {
9228                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9229         }
9230         ndr->depth--;
9231         ndr_print_uint32(ndr, "level", r->level);
9232         ndr_print_ptr(ndr, "error", r->error);
9233         ndr->depth++;
9234         if (r->error) {
9235                 ndr_print_set_switch_value(ndr, r->error, r->level);
9236                 ndr_print_drsuapi_DsAddEntryError(ndr, "error", r->error);
9237         }
9238         ndr->depth--;
9239         ndr_print_uint32(ndr, "count", r->count);
9240         ndr_print_ptr(ndr, "objects", r->objects);
9241         ndr->depth++;
9242         if (r->objects) {
9243                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9244                 ndr->depth++;
9245                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9246                         char *idx_1=NULL;
9247                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9248                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9249                                 free(idx_1);
9250                         }
9251                 }
9252                 ndr->depth--;
9253         }
9254         ndr->depth--;
9255         ndr->depth--;
9256 }
9257
9258 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryCtr *r)
9259 {
9260         if (ndr_flags & NDR_SCALARS) {
9261                 int level = ndr_push_get_switch_value(ndr, r);
9262                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
9263                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9264                 switch (level) {
9265                         case 2: {
9266                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9267                         break; }
9268
9269                         case 3: {
9270                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9271                         break; }
9272
9273                         default:
9274                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9275                 }
9276         }
9277         if (ndr_flags & NDR_BUFFERS) {
9278                 int level = ndr_push_get_switch_value(ndr, r);
9279                 switch (level) {
9280                         case 2:
9281                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9282                         break;
9283
9284                         case 3:
9285                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9286                         break;
9287
9288                         default:
9289                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9290                 }
9291         }
9292         return NDR_ERR_SUCCESS;
9293 }
9294
9295 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryCtr *r)
9296 {
9297         int level;
9298         int32_t _level;
9299         level = ndr_pull_get_switch_value(ndr, r);
9300         if (ndr_flags & NDR_SCALARS) {
9301                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
9302                 if (_level != level) {
9303                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9304                 }
9305                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9306                 switch (level) {
9307                         case 2: {
9308                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9309                         break; }
9310
9311                         case 3: {
9312                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9313                         break; }
9314
9315                         default:
9316                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9317                 }
9318         }
9319         if (ndr_flags & NDR_BUFFERS) {
9320                 switch (level) {
9321                         case 2:
9322                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9323                         break;
9324
9325                         case 3:
9326                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9327                         break;
9328
9329                         default:
9330                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9331                 }
9332         }
9333         return NDR_ERR_SUCCESS;
9334 }
9335
9336 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
9337 {
9338         int level;
9339         level = ndr_print_get_switch_value(ndr, r);
9340         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
9341         switch (level) {
9342                 case 2:
9343                         ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
9344                 break;
9345
9346                 case 3:
9347                         ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
9348                 break;
9349
9350                 default:
9351                         ndr_print_bad_level(ndr, name, level);
9352         }
9353 }
9354
9355 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9356 {
9357         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9358         return NDR_ERR_SUCCESS;
9359 }
9360
9361 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9362 {
9363         uint32_t v;
9364         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9365         *r = v;
9366         return NDR_ERR_SUCCESS;
9367 }
9368
9369 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCFlags(struct ndr_print *ndr, const char *name, uint32_t r)
9370 {
9371         ndr_print_uint32(ndr, name, r);
9372         ndr->depth++;
9373         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION, r);
9374         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_DAMPED", DRSUAPI_DS_EXECUTE_KCC_DAMPED, r);
9375         ndr->depth--;
9376 }
9377
9378 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsExecuteKCC1 *r)
9379 {
9380         if (ndr_flags & NDR_SCALARS) {
9381                 NDR_CHECK(ndr_push_align(ndr, 4));
9382                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->taskID));
9383                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, r->flags));
9384                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9385         }
9386         if (ndr_flags & NDR_BUFFERS) {
9387         }
9388         return NDR_ERR_SUCCESS;
9389 }
9390
9391 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsExecuteKCC1 *r)
9392 {
9393         if (ndr_flags & NDR_SCALARS) {
9394                 NDR_CHECK(ndr_pull_align(ndr, 4));
9395                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->taskID));
9396                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, &r->flags));
9397                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9398         }
9399         if (ndr_flags & NDR_BUFFERS) {
9400         }
9401         return NDR_ERR_SUCCESS;
9402 }
9403
9404 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsExecuteKCC1 *r)
9405 {
9406         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC1");
9407         ndr->depth++;
9408         ndr_print_uint32(ndr, "taskID", r->taskID);
9409         ndr_print_drsuapi_DsExecuteKCCFlags(ndr, "flags", r->flags);
9410         ndr->depth--;
9411 }
9412
9413 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsExecuteKCCRequest *r)
9414 {
9415         if (ndr_flags & NDR_SCALARS) {
9416                 int level = ndr_push_get_switch_value(ndr, r);
9417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9418                 NDR_CHECK(ndr_push_union_align(ndr, 4));
9419                 switch (level) {
9420                         case 1: {
9421                                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9422                         break; }
9423
9424                         default:
9425                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9426                 }
9427         }
9428         if (ndr_flags & NDR_BUFFERS) {
9429                 int level = ndr_push_get_switch_value(ndr, r);
9430                 switch (level) {
9431                         case 1:
9432                         break;
9433
9434                         default:
9435                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9436                 }
9437         }
9438         return NDR_ERR_SUCCESS;
9439 }
9440
9441 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsExecuteKCCRequest *r)
9442 {
9443         int level;
9444         uint32_t _level;
9445         level = ndr_pull_get_switch_value(ndr, r);
9446         if (ndr_flags & NDR_SCALARS) {
9447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9448                 if (_level != level) {
9449                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9450                 }
9451                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
9452                 switch (level) {
9453                         case 1: {
9454                                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9455                         break; }
9456
9457                         default:
9458                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9459                 }
9460         }
9461         if (ndr_flags & NDR_BUFFERS) {
9462                 switch (level) {
9463                         case 1:
9464                         break;
9465
9466                         default:
9467                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9468                 }
9469         }
9470         return NDR_ERR_SUCCESS;
9471 }
9472
9473 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsExecuteKCCRequest *r)
9474 {
9475         int level;
9476         level = ndr_print_get_switch_value(ndr, r);
9477         ndr_print_union(ndr, name, level, "drsuapi_DsExecuteKCCRequest");
9478         switch (level) {
9479                 case 1:
9480                         ndr_print_drsuapi_DsExecuteKCC1(ndr, "ctr1", &r->ctr1);
9481                 break;
9482
9483                 default:
9484                         ndr_print_bad_level(ndr, name, level);
9485         }
9486 }
9487
9488 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
9489 {
9490         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9491         return NDR_ERR_SUCCESS;
9492 }
9493
9494 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
9495 {
9496         uint32_t v;
9497         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9498         *r = v;
9499         return NDR_ERR_SUCCESS;
9500 }
9501
9502 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaGetInfoLevel r)
9503 {
9504         const char *val = NULL;
9505
9506         switch (r) {
9507                 case DRSUAPI_DS_REPLICA_GET_INFO: val = "DRSUAPI_DS_REPLICA_GET_INFO"; break;
9508                 case DRSUAPI_DS_REPLICA_GET_INFO2: val = "DRSUAPI_DS_REPLICA_GET_INFO2"; break;
9509         }
9510         ndr_print_enum(ndr, name, "ENUM", val, r);
9511 }
9512
9513 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
9514 {
9515         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9516         return NDR_ERR_SUCCESS;
9517 }
9518
9519 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
9520 {
9521         uint32_t v;
9522         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9523         *r = v;
9524         return NDR_ERR_SUCCESS;
9525 }
9526
9527 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaInfoType r)
9528 {
9529         const char *val = NULL;
9530
9531         switch (r) {
9532                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS"; break;
9533                 case DRSUAPI_DS_REPLICA_INFO_CURSORS: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS"; break;
9534                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA"; break;
9535                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES"; break;
9536                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES"; break;
9537                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: val = "DRSUAPI_DS_REPLICA_INFO_PENDING_OPS"; break;
9538                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA"; break;
9539                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS2"; break;
9540                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS3"; break;
9541                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2"; break;
9542                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2"; break;
9543                 case DRSUAPI_DS_REPLICA_INFO_REPSTO: val = "DRSUAPI_DS_REPLICA_INFO_REPSTO"; break;
9544                 case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS: val = "DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS"; break;
9545                 case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1: val = "DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1"; break;
9546                 case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS: val = "DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS"; break;
9547         }
9548         ndr_print_enum(ndr, name, "ENUM", val, r);
9549 }
9550
9551 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9552 {
9553         if (ndr_flags & NDR_SCALARS) {
9554                 NDR_CHECK(ndr_push_align(ndr, 5));
9555                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9556                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9557                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
9558                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9559         }
9560         if (ndr_flags & NDR_BUFFERS) {
9561                 if (r->object_dn) {
9562                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9563                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9564                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9565                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9566                 }
9567         }
9568         return NDR_ERR_SUCCESS;
9569 }
9570
9571 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
9572 {
9573         uint32_t _ptr_object_dn;
9574         TALLOC_CTX *_mem_save_object_dn_0;
9575         if (ndr_flags & NDR_SCALARS) {
9576                 NDR_CHECK(ndr_pull_align(ndr, 5));
9577                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9578                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9579                 if (_ptr_object_dn) {
9580                         NDR_PULL_ALLOC(ndr, r->object_dn);
9581                 } else {
9582                         r->object_dn = NULL;
9583                 }
9584                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
9585                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9586         }
9587         if (ndr_flags & NDR_BUFFERS) {
9588                 if (r->object_dn) {
9589                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9590                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9591                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9592                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9593                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9594                                 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));
9595                         }
9596                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9597                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9598                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9599                 }
9600         }
9601         return NDR_ERR_SUCCESS;
9602 }
9603
9604 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9605 {
9606         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest1");
9607         ndr->depth++;
9608         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9609         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9610         ndr->depth++;
9611         if (r->object_dn) {
9612                 ndr_print_string(ndr, "object_dn", r->object_dn);
9613         }
9614         ndr->depth--;
9615         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
9616         ndr->depth--;
9617 }
9618
9619 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9620 {
9621         if (ndr_flags & NDR_SCALARS) {
9622                 NDR_CHECK(ndr_push_align(ndr, 5));
9623                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9624                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9625                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
9626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
9627                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
9628                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->value_dn_str));
9629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
9630                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9631         }
9632         if (ndr_flags & NDR_BUFFERS) {
9633                 if (r->object_dn) {
9634                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9635                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9636                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9637                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9638                 }
9639                 if (r->attribute_name) {
9640                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
9641                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9642                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
9643                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9644                 }
9645                 if (r->value_dn_str) {
9646                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->value_dn_str, CH_UTF16)));
9647                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9648                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->value_dn_str, CH_UTF16)));
9649                         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));
9650                 }
9651         }
9652         return NDR_ERR_SUCCESS;
9653 }
9654
9655 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
9656 {
9657         uint32_t _ptr_object_dn;
9658         TALLOC_CTX *_mem_save_object_dn_0;
9659         uint32_t _ptr_attribute_name;
9660         TALLOC_CTX *_mem_save_attribute_name_0;
9661         uint32_t _ptr_value_dn_str;
9662         TALLOC_CTX *_mem_save_value_dn_str_0;
9663         if (ndr_flags & NDR_SCALARS) {
9664                 NDR_CHECK(ndr_pull_align(ndr, 5));
9665                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9667                 if (_ptr_object_dn) {
9668                         NDR_PULL_ALLOC(ndr, r->object_dn);
9669                 } else {
9670                         r->object_dn = NULL;
9671                 }
9672                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
9673                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
9674                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
9675                 if (_ptr_attribute_name) {
9676                         NDR_PULL_ALLOC(ndr, r->attribute_name);
9677                 } else {
9678                         r->attribute_name = NULL;
9679                 }
9680                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_dn_str));
9681                 if (_ptr_value_dn_str) {
9682                         NDR_PULL_ALLOC(ndr, r->value_dn_str);
9683                 } else {
9684                         r->value_dn_str = NULL;
9685                 }
9686                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
9687                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9688         }
9689         if (ndr_flags & NDR_BUFFERS) {
9690                 if (r->object_dn) {
9691                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9692                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9693                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9694                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9695                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9696                                 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));
9697                         }
9698                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9699                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9700                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9701                 }
9702                 if (r->attribute_name) {
9703                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9704                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
9705                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
9706                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
9707                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
9708                                 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));
9709                         }
9710                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
9711                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
9712                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
9713                 }
9714                 if (r->value_dn_str) {
9715                         _mem_save_value_dn_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
9716                         NDR_PULL_SET_MEM_CTX(ndr, r->value_dn_str, 0);
9717                         NDR_CHECK(ndr_pull_array_size(ndr, &r->value_dn_str));
9718                         NDR_CHECK(ndr_pull_array_length(ndr, &r->value_dn_str));
9719                         if (ndr_get_array_length(ndr, &r->value_dn_str) > ndr_get_array_size(ndr, &r->value_dn_str)) {
9720                                 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));
9721                         }
9722                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->value_dn_str), sizeof(uint16_t)));
9723                         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));
9724                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_dn_str_0, 0);
9725                 }
9726         }
9727         return NDR_ERR_SUCCESS;
9728 }
9729
9730 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9731 {
9732         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest2");
9733         ndr->depth++;
9734         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9735         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9736         ndr->depth++;
9737         if (r->object_dn) {
9738                 ndr_print_string(ndr, "object_dn", r->object_dn);
9739         }
9740         ndr->depth--;
9741         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
9742         ndr_print_uint32(ndr, "flags", r->flags);
9743         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
9744         ndr->depth++;
9745         if (r->attribute_name) {
9746                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
9747         }
9748         ndr->depth--;
9749         ndr_print_ptr(ndr, "value_dn_str", r->value_dn_str);
9750         ndr->depth++;
9751         if (r->value_dn_str) {
9752                 ndr_print_string(ndr, "value_dn_str", r->value_dn_str);
9753         }
9754         ndr->depth--;
9755         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
9756         ndr->depth--;
9757 }
9758
9759 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaGetInfoRequest *r)
9760 {
9761         if (ndr_flags & NDR_SCALARS) {
9762                 int level = ndr_push_get_switch_value(ndr, r);
9763                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
9764                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9765                 switch (level) {
9766                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9767                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9768                         break; }
9769
9770                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9771                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9772                         break; }
9773
9774                         default:
9775                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9776                 }
9777         }
9778         if (ndr_flags & NDR_BUFFERS) {
9779                 int level = ndr_push_get_switch_value(ndr, r);
9780                 switch (level) {
9781                         case DRSUAPI_DS_REPLICA_GET_INFO:
9782                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9783                         break;
9784
9785                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9786                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9787                         break;
9788
9789                         default:
9790                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9791                 }
9792         }
9793         return NDR_ERR_SUCCESS;
9794 }
9795
9796 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaGetInfoRequest *r)
9797 {
9798         int level;
9799         uint32_t _level;
9800         level = ndr_pull_get_switch_value(ndr, r);
9801         if (ndr_flags & NDR_SCALARS) {
9802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9803                 if (_level != level) {
9804                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9805                 }
9806                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9807                 switch (level) {
9808                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9809                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9810                         break; }
9811
9812                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9813                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9814                         break; }
9815
9816                         default:
9817                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9818                 }
9819         }
9820         if (ndr_flags & NDR_BUFFERS) {
9821                 switch (level) {
9822                         case DRSUAPI_DS_REPLICA_GET_INFO:
9823                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9824                         break;
9825
9826                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9827                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9828                         break;
9829
9830                         default:
9831                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9832                 }
9833         }
9834         return NDR_ERR_SUCCESS;
9835 }
9836
9837 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaGetInfoRequest *r)
9838 {
9839         int level;
9840         level = ndr_print_get_switch_value(ndr, r);
9841         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaGetInfoRequest");
9842         switch (level) {
9843                 case DRSUAPI_DS_REPLICA_GET_INFO:
9844                         ndr_print_drsuapi_DsReplicaGetInfoRequest1(ndr, "req1", &r->req1);
9845                 break;
9846
9847                 case DRSUAPI_DS_REPLICA_GET_INFO2:
9848                         ndr_print_drsuapi_DsReplicaGetInfoRequest2(ndr, "req2", &r->req2);
9849                 break;
9850
9851                 default:
9852                         ndr_print_bad_level(ndr, name, level);
9853         }
9854 }
9855
9856 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbour *r)
9857 {
9858         if (ndr_flags & NDR_SCALARS) {
9859                 NDR_CHECK(ndr_push_align(ndr, 8));
9860                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context_dn));
9861                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
9862                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
9863                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_obj_dn));
9864                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
9865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9866                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9867                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9868                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9869                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9870                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
9871                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
9872                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_success));
9873                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
9874                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
9875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
9876                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9877         }
9878         if (ndr_flags & NDR_BUFFERS) {
9879                 if (r->naming_context_dn) {
9880                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9881                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9882                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9883                         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));
9884                 }
9885                 if (r->source_dsa_obj_dn) {
9886                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9887                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9888                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9889                         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));
9890                 }
9891                 if (r->source_dsa_address) {
9892                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9893                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9894                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9895                         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));
9896                 }
9897                 if (r->transport_obj_dn) {
9898                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9899                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9900                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9901                         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));
9902                 }
9903         }
9904         return NDR_ERR_SUCCESS;
9905 }
9906
9907 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
9908 {
9909         uint32_t _ptr_naming_context_dn;
9910         TALLOC_CTX *_mem_save_naming_context_dn_0;
9911         uint32_t _ptr_source_dsa_obj_dn;
9912         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
9913         uint32_t _ptr_source_dsa_address;
9914         TALLOC_CTX *_mem_save_source_dsa_address_0;
9915         uint32_t _ptr_transport_obj_dn;
9916         TALLOC_CTX *_mem_save_transport_obj_dn_0;
9917         if (ndr_flags & NDR_SCALARS) {
9918                 NDR_CHECK(ndr_pull_align(ndr, 8));
9919                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context_dn));
9920                 if (_ptr_naming_context_dn) {
9921                         NDR_PULL_ALLOC(ndr, r->naming_context_dn);
9922                 } else {
9923                         r->naming_context_dn = NULL;
9924                 }
9925                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
9926                 if (_ptr_source_dsa_obj_dn) {
9927                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
9928                 } else {
9929                         r->source_dsa_obj_dn = NULL;
9930                 }
9931                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
9932                 if (_ptr_source_dsa_address) {
9933                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
9934                 } else {
9935                         r->source_dsa_address = NULL;
9936                 }
9937                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_obj_dn));
9938                 if (_ptr_transport_obj_dn) {
9939                         NDR_PULL_ALLOC(ndr, r->transport_obj_dn);
9940                 } else {
9941                         r->transport_obj_dn = NULL;
9942                 }
9943                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
9944                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9945                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9946                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9947                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9948                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9949                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
9950                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
9951                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_success));
9952                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
9953                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
9954                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
9955                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
9956         }
9957         if (ndr_flags & NDR_BUFFERS) {
9958                 if (r->naming_context_dn) {
9959                         _mem_save_naming_context_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9960                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
9961                         NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
9962                         NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
9963                         if (ndr_get_array_length(ndr, &r->naming_context_dn) > ndr_get_array_size(ndr, &r->naming_context_dn)) {
9964                                 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));
9965                         }
9966                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t)));
9967                         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));
9968                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
9969                 }
9970                 if (r->source_dsa_obj_dn) {
9971                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9972                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
9973                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
9974                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
9975                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
9976                                 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));
9977                         }
9978                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
9979                         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));
9980                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
9981                 }
9982                 if (r->source_dsa_address) {
9983                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
9984                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
9985                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
9986                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
9987                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
9988                                 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));
9989                         }
9990                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
9991                         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));
9992                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
9993                 }
9994                 if (r->transport_obj_dn) {
9995                         _mem_save_transport_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9996                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
9997                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
9998                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
9999                         if (ndr_get_array_length(ndr, &r->transport_obj_dn) > ndr_get_array_size(ndr, &r->transport_obj_dn)) {
10000                                 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));
10001                         }
10002                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t)));
10003                         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));
10004                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
10005                 }
10006         }
10007         return NDR_ERR_SUCCESS;
10008 }
10009
10010 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbour(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbour *r)
10011 {
10012         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbour");
10013         ndr->depth++;
10014         ndr_print_ptr(ndr, "naming_context_dn", r->naming_context_dn);
10015         ndr->depth++;
10016         if (r->naming_context_dn) {
10017                 ndr_print_string(ndr, "naming_context_dn", r->naming_context_dn);
10018         }
10019         ndr->depth--;
10020         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10021         ndr->depth++;
10022         if (r->source_dsa_obj_dn) {
10023                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10024         }
10025         ndr->depth--;
10026         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
10027         ndr->depth++;
10028         if (r->source_dsa_address) {
10029                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
10030         }
10031         ndr->depth--;
10032         ndr_print_ptr(ndr, "transport_obj_dn", r->transport_obj_dn);
10033         ndr->depth++;
10034         if (r->transport_obj_dn) {
10035                 ndr_print_string(ndr, "transport_obj_dn", r->transport_obj_dn);
10036         }
10037         ndr->depth--;
10038         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
10039         ndr_print_uint32(ndr, "reserved", r->reserved);
10040         ndr_print_GUID(ndr, "naming_context_obj_guid", &r->naming_context_obj_guid);
10041         ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
10042         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
10043         ndr_print_GUID(ndr, "transport_obj_guid", &r->transport_obj_guid);
10044         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
10045         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
10046         ndr_print_NTTIME(ndr, "last_success", r->last_success);
10047         ndr_print_NTTIME(ndr, "last_attempt", r->last_attempt);
10048         ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
10049         ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
10050         ndr->depth--;
10051 }
10052
10053 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbourCtr *r)
10054 {
10055         uint32_t cntr_array_0;
10056         if (ndr_flags & NDR_SCALARS) {
10057                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10058                 NDR_CHECK(ndr_push_align(ndr, 8));
10059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10060                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10061                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10062                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10063                 }
10064                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10065         }
10066         if (ndr_flags & NDR_BUFFERS) {
10067                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10068                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10069                 }
10070         }
10071         return NDR_ERR_SUCCESS;
10072 }
10073
10074 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
10075 {
10076         uint32_t cntr_array_0;
10077         TALLOC_CTX *_mem_save_array_0;
10078         if (ndr_flags & NDR_SCALARS) {
10079                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10080                 NDR_CHECK(ndr_pull_align(ndr, 8));
10081                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10082                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10083                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10084                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10085                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10086                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10087                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10088                 }
10089                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10090                 if (r->array) {
10091                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10092                 }
10093                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10094         }
10095         if (ndr_flags & NDR_BUFFERS) {
10096                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10097                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10098                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10099                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10100                 }
10101                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10102         }
10103         return NDR_ERR_SUCCESS;
10104 }
10105
10106 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbourCtr *r)
10107 {
10108         uint32_t cntr_array_0;
10109         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbourCtr");
10110         ndr->depth++;
10111         ndr_print_uint32(ndr, "count", r->count);
10112         ndr_print_uint32(ndr, "reserved", r->reserved);
10113         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10114         ndr->depth++;
10115         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10116                 char *idx_0=NULL;
10117                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10118                         ndr_print_drsuapi_DsReplicaNeighbour(ndr, "array", &r->array[cntr_array_0]);
10119                         free(idx_0);
10120                 }
10121         }
10122         ndr->depth--;
10123         ndr->depth--;
10124 }
10125
10126 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtr *r)
10127 {
10128         uint32_t cntr_array_0;
10129         if (ndr_flags & NDR_SCALARS) {
10130                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10131                 NDR_CHECK(ndr_push_align(ndr, 8));
10132                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10134                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10135                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10136                 }
10137                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10138         }
10139         if (ndr_flags & NDR_BUFFERS) {
10140         }
10141         return NDR_ERR_SUCCESS;
10142 }
10143
10144 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
10145 {
10146         uint32_t cntr_array_0;
10147         TALLOC_CTX *_mem_save_array_0;
10148         if (ndr_flags & NDR_SCALARS) {
10149                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10150                 NDR_CHECK(ndr_pull_align(ndr, 8));
10151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10153                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10154                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10155                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10156                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10157                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10158                 }
10159                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10160                 if (r->array) {
10161                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10162                 }
10163                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10164         }
10165         if (ndr_flags & NDR_BUFFERS) {
10166         }
10167         return NDR_ERR_SUCCESS;
10168 }
10169
10170 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtr *r)
10171 {
10172         uint32_t cntr_array_0;
10173         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtr");
10174         ndr->depth++;
10175         ndr_print_uint32(ndr, "count", r->count);
10176         ndr_print_uint32(ndr, "reserved", r->reserved);
10177         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10178         ndr->depth++;
10179         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10180                 char *idx_0=NULL;
10181                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10182                         ndr_print_drsuapi_DsReplicaCursor(ndr, "array", &r->array[cntr_array_0]);
10183                         free(idx_0);
10184                 }
10185         }
10186         ndr->depth--;
10187         ndr->depth--;
10188 }
10189
10190 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData *r)
10191 {
10192         if (ndr_flags & NDR_SCALARS) {
10193                 NDR_CHECK(ndr_push_align(ndr, 8));
10194                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10195                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10196                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10197                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10198                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10199                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10200                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10201         }
10202         if (ndr_flags & NDR_BUFFERS) {
10203                 if (r->attribute_name) {
10204                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10205                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10206                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10207                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10208                 }
10209         }
10210         return NDR_ERR_SUCCESS;
10211 }
10212
10213 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
10214 {
10215         uint32_t _ptr_attribute_name;
10216         TALLOC_CTX *_mem_save_attribute_name_0;
10217         if (ndr_flags & NDR_SCALARS) {
10218                 NDR_CHECK(ndr_pull_align(ndr, 8));
10219                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10220                 if (_ptr_attribute_name) {
10221                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10222                 } else {
10223                         r->attribute_name = NULL;
10224                 }
10225                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10226                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10227                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10228                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10229                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10230                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10231         }
10232         if (ndr_flags & NDR_BUFFERS) {
10233                 if (r->attribute_name) {
10234                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10235                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10236                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10237                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10238                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10239                                 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));
10240                         }
10241                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10242                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10243                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10244                 }
10245         }
10246         return NDR_ERR_SUCCESS;
10247 }
10248
10249 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData *r)
10250 {
10251         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData");
10252         ndr->depth++;
10253         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10254         ndr->depth++;
10255         if (r->attribute_name) {
10256                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10257         }
10258         ndr->depth--;
10259         ndr_print_uint32(ndr, "version", r->version);
10260         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10261         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10262         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10263         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10264         ndr->depth--;
10265 }
10266
10267 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10268 {
10269         uint32_t cntr_array_0;
10270         if (ndr_flags & NDR_SCALARS) {
10271                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10272                 NDR_CHECK(ndr_push_align(ndr, 8));
10273                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10274                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10275                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10276                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10277                 }
10278                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10279         }
10280         if (ndr_flags & NDR_BUFFERS) {
10281                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10282                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10283                 }
10284         }
10285         return NDR_ERR_SUCCESS;
10286 }
10287
10288 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
10289 {
10290         uint32_t cntr_array_0;
10291         TALLOC_CTX *_mem_save_array_0;
10292         if (ndr_flags & NDR_SCALARS) {
10293                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10294                 NDR_CHECK(ndr_pull_align(ndr, 8));
10295                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10297                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10298                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10299                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10300                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10301                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10302                 }
10303                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10304                 if (r->array) {
10305                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10306                 }
10307                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10308         }
10309         if (ndr_flags & NDR_BUFFERS) {
10310                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10311                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10312                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10313                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10314                 }
10315                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10316         }
10317         return NDR_ERR_SUCCESS;
10318 }
10319
10320 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10321 {
10322         uint32_t cntr_array_0;
10323         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaDataCtr");
10324         ndr->depth++;
10325         ndr_print_uint32(ndr, "count", r->count);
10326         ndr_print_uint32(ndr, "reserved", r->reserved);
10327         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10328         ndr->depth++;
10329         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10330                 char *idx_0=NULL;
10331                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10332                         ndr_print_drsuapi_DsReplicaObjMetaData(ndr, "array", &r->array[cntr_array_0]);
10333                         free(idx_0);
10334                 }
10335         }
10336         ndr->depth--;
10337         ndr->depth--;
10338 }
10339
10340 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
10341 {
10342         if (ndr_flags & NDR_SCALARS) {
10343                 NDR_CHECK(ndr_push_align(ndr, 5));
10344                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
10345                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10346                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
10347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
10348                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
10349                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10350         }
10351         if (ndr_flags & NDR_BUFFERS) {
10352                 if (r->dsa_obj_dn) {
10353                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10354                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10355                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10356                         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));
10357                 }
10358         }
10359         return NDR_ERR_SUCCESS;
10360 }
10361
10362 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
10363 {
10364         uint32_t _ptr_dsa_obj_dn;
10365         TALLOC_CTX *_mem_save_dsa_obj_dn_0;
10366         if (ndr_flags & NDR_SCALARS) {
10367                 NDR_CHECK(ndr_pull_align(ndr, 5));
10368                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
10369                 if (_ptr_dsa_obj_dn) {
10370                         NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
10371                 } else {
10372                         r->dsa_obj_dn = NULL;
10373                 }
10374                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10375                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
10376                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
10377                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
10378                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10379         }
10380         if (ndr_flags & NDR_BUFFERS) {
10381                 if (r->dsa_obj_dn) {
10382                         _mem_save_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10383                         NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
10384                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
10385                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
10386                         if (ndr_get_array_length(ndr, &r->dsa_obj_dn) > ndr_get_array_size(ndr, &r->dsa_obj_dn)) {
10387                                 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));
10388                         }
10389                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t)));
10390                         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));
10391                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
10392                 }
10393         }
10394         return NDR_ERR_SUCCESS;
10395 }
10396
10397 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailure(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailure *r)
10398 {
10399         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailure");
10400         ndr->depth++;
10401         ndr_print_ptr(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10402         ndr->depth++;
10403         if (r->dsa_obj_dn) {
10404                 ndr_print_string(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10405         }
10406         ndr->depth--;
10407         ndr_print_GUID(ndr, "dsa_obj_guid", &r->dsa_obj_guid);
10408         ndr_print_NTTIME(ndr, "first_failure", r->first_failure);
10409         ndr_print_uint32(ndr, "num_failures", r->num_failures);
10410         ndr_print_WERROR(ndr, "last_result", r->last_result);
10411         ndr->depth--;
10412 }
10413
10414 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10415 {
10416         uint32_t cntr_array_0;
10417         if (ndr_flags & NDR_SCALARS) {
10418                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10419                 NDR_CHECK(ndr_push_align(ndr, 5));
10420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10422                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10423                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10424                 }
10425                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10426         }
10427         if (ndr_flags & NDR_BUFFERS) {
10428                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10429                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10430                 }
10431         }
10432         return NDR_ERR_SUCCESS;
10433 }
10434
10435 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10436 {
10437         uint32_t cntr_array_0;
10438         TALLOC_CTX *_mem_save_array_0;
10439         if (ndr_flags & NDR_SCALARS) {
10440                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10441                 NDR_CHECK(ndr_pull_align(ndr, 5));
10442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10444                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10445                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10446                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10447                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10448                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10449                 }
10450                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10451                 if (r->array) {
10452                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10453                 }
10454                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10455         }
10456         if (ndr_flags & NDR_BUFFERS) {
10457                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10458                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10459                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10460                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10461                 }
10462                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10463         }
10464         return NDR_ERR_SUCCESS;
10465 }
10466
10467 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10468 {
10469         uint32_t cntr_array_0;
10470         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailuresCtr");
10471         ndr->depth++;
10472         ndr_print_uint32(ndr, "count", r->count);
10473         ndr_print_uint32(ndr, "reserved", r->reserved);
10474         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10475         ndr->depth++;
10476         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10477                 char *idx_0=NULL;
10478                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10479                         ndr_print_drsuapi_DsReplicaKccDsaFailure(ndr, "array", &r->array[cntr_array_0]);
10480                         free(idx_0);
10481                 }
10482         }
10483         ndr->depth--;
10484         ndr->depth--;
10485 }
10486
10487 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
10488 {
10489         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
10490         return NDR_ERR_SUCCESS;
10491 }
10492
10493 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
10494 {
10495         uint16_t v;
10496         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
10497         *r = v;
10498         return NDR_ERR_SUCCESS;
10499 }
10500
10501 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaOpType r)
10502 {
10503         const char *val = NULL;
10504
10505         switch (r) {
10506                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: val = "DRSUAPI_DS_REPLICA_OP_TYPE_SYNC"; break;
10507                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: val = "DRSUAPI_DS_REPLICA_OP_TYPE_ADD"; break;
10508                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: val = "DRSUAPI_DS_REPLICA_OP_TYPE_DELETE"; break;
10509                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: val = "DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY"; break;
10510                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: val = "DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS"; break;
10511         }
10512         ndr_print_enum(ndr, name, "ENUM", val, r);
10513 }
10514
10515 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
10516 {
10517         if (ndr_flags & NDR_SCALARS) {
10518                 NDR_CHECK(ndr_push_align(ndr, 5));
10519                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
10520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
10521                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
10522                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
10523                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
10524                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
10525                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
10526                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
10527                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10528                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10529                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10530         }
10531         if (ndr_flags & NDR_BUFFERS) {
10532                 if (r->nc_dn) {
10533                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10534                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10535                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10536                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10537                 }
10538                 if (r->remote_dsa_obj_dn) {
10539                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10540                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10541                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10542                         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));
10543                 }
10544                 if (r->remote_dsa_address) {
10545                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10546                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10547                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10548                         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));
10549                 }
10550         }
10551         return NDR_ERR_SUCCESS;
10552 }
10553
10554 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
10555 {
10556         uint32_t _ptr_nc_dn;
10557         TALLOC_CTX *_mem_save_nc_dn_0;
10558         uint32_t _ptr_remote_dsa_obj_dn;
10559         TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
10560         uint32_t _ptr_remote_dsa_address;
10561         TALLOC_CTX *_mem_save_remote_dsa_address_0;
10562         if (ndr_flags & NDR_SCALARS) {
10563                 NDR_CHECK(ndr_pull_align(ndr, 5));
10564                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
10565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
10566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
10567                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
10568                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
10569                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
10570                 if (_ptr_nc_dn) {
10571                         NDR_PULL_ALLOC(ndr, r->nc_dn);
10572                 } else {
10573                         r->nc_dn = NULL;
10574                 }
10575                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_obj_dn));
10576                 if (_ptr_remote_dsa_obj_dn) {
10577                         NDR_PULL_ALLOC(ndr, r->remote_dsa_obj_dn);
10578                 } else {
10579                         r->remote_dsa_obj_dn = NULL;
10580                 }
10581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_address));
10582                 if (_ptr_remote_dsa_address) {
10583                         NDR_PULL_ALLOC(ndr, r->remote_dsa_address);
10584                 } else {
10585                         r->remote_dsa_address = NULL;
10586                 }
10587                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10588                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10589                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10590         }
10591         if (ndr_flags & NDR_BUFFERS) {
10592                 if (r->nc_dn) {
10593                         _mem_save_nc_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10594                         NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
10595                         NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
10596                         NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
10597                         if (ndr_get_array_length(ndr, &r->nc_dn) > ndr_get_array_size(ndr, &r->nc_dn)) {
10598                                 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));
10599                         }
10600                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t)));
10601                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t), CH_UTF16));
10602                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
10603                 }
10604                 if (r->remote_dsa_obj_dn) {
10605                         _mem_save_remote_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10606                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
10607                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
10608                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
10609                         if (ndr_get_array_length(ndr, &r->remote_dsa_obj_dn) > ndr_get_array_size(ndr, &r->remote_dsa_obj_dn)) {
10610                                 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));
10611                         }
10612                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t)));
10613                         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));
10614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
10615                 }
10616                 if (r->remote_dsa_address) {
10617                         _mem_save_remote_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10618                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
10619                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
10620                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
10621                         if (ndr_get_array_length(ndr, &r->remote_dsa_address) > ndr_get_array_size(ndr, &r->remote_dsa_address)) {
10622                                 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));
10623                         }
10624                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t)));
10625                         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));
10626                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
10627                 }
10628         }
10629         return NDR_ERR_SUCCESS;
10630 }
10631
10632 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOp *r)
10633 {
10634         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOp");
10635         ndr->depth++;
10636         ndr_print_NTTIME(ndr, "operation_start", r->operation_start);
10637         ndr_print_uint32(ndr, "serial_num", r->serial_num);
10638         ndr_print_uint32(ndr, "priority", r->priority);
10639         ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
10640         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
10641         ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
10642         ndr->depth++;
10643         if (r->nc_dn) {
10644                 ndr_print_string(ndr, "nc_dn", r->nc_dn);
10645         }
10646         ndr->depth--;
10647         ndr_print_ptr(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10648         ndr->depth++;
10649         if (r->remote_dsa_obj_dn) {
10650                 ndr_print_string(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10651         }
10652         ndr->depth--;
10653         ndr_print_ptr(ndr, "remote_dsa_address", r->remote_dsa_address);
10654         ndr->depth++;
10655         if (r->remote_dsa_address) {
10656                 ndr_print_string(ndr, "remote_dsa_address", r->remote_dsa_address);
10657         }
10658         ndr->depth--;
10659         ndr_print_GUID(ndr, "nc_obj_guid", &r->nc_obj_guid);
10660         ndr_print_GUID(ndr, "remote_dsa_obj_guid", &r->remote_dsa_obj_guid);
10661         ndr->depth--;
10662 }
10663
10664 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOpCtr *r)
10665 {
10666         uint32_t cntr_array_0;
10667         if (ndr_flags & NDR_SCALARS) {
10668                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10669                 NDR_CHECK(ndr_push_align(ndr, 5));
10670                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
10671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10672                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10673                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10674                 }
10675                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10676         }
10677         if (ndr_flags & NDR_BUFFERS) {
10678                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10679                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10680                 }
10681         }
10682         return NDR_ERR_SUCCESS;
10683 }
10684
10685 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
10686 {
10687         uint32_t cntr_array_0;
10688         TALLOC_CTX *_mem_save_array_0;
10689         if (ndr_flags & NDR_SCALARS) {
10690                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10691                 NDR_CHECK(ndr_pull_align(ndr, 5));
10692                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
10693                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10694                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10695                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10696                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10697                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10698                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10699                 }
10700                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10701                 if (r->array) {
10702                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10703                 }
10704                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10705         }
10706         if (ndr_flags & NDR_BUFFERS) {
10707                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10708                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10709                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10710                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10711                 }
10712                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10713         }
10714         return NDR_ERR_SUCCESS;
10715 }
10716
10717 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOpCtr *r)
10718 {
10719         uint32_t cntr_array_0;
10720         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOpCtr");
10721         ndr->depth++;
10722         ndr_print_NTTIME(ndr, "time", r->time);
10723         ndr_print_uint32(ndr, "count", r->count);
10724         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10725         ndr->depth++;
10726         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10727                 char *idx_0=NULL;
10728                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10729                         ndr_print_drsuapi_DsReplicaOp(ndr, "array", &r->array[cntr_array_0]);
10730                         free(idx_0);
10731                 }
10732         }
10733         ndr->depth--;
10734         ndr->depth--;
10735 }
10736
10737 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData *r)
10738 {
10739         if (ndr_flags & NDR_SCALARS) {
10740                 NDR_CHECK(ndr_push_align(ndr, 8));
10741                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10742                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
10743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
10744                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
10745                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
10746                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
10747                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10748                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10749                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10750                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10751                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10752                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10753         }
10754         if (ndr_flags & NDR_BUFFERS) {
10755                 if (r->attribute_name) {
10756                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10757                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10758                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10759                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10760                 }
10761                 if (r->object_dn) {
10762                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10763                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10764                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10765                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10766                 }
10767                 if (r->binary) {
10768                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
10769                 }
10770         }
10771         return NDR_ERR_SUCCESS;
10772 }
10773
10774 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
10775 {
10776         uint32_t _ptr_attribute_name;
10777         TALLOC_CTX *_mem_save_attribute_name_0;
10778         uint32_t _ptr_object_dn;
10779         TALLOC_CTX *_mem_save_object_dn_0;
10780         uint32_t _ptr_binary;
10781         TALLOC_CTX *_mem_save_binary_0;
10782         if (ndr_flags & NDR_SCALARS) {
10783                 NDR_CHECK(ndr_pull_align(ndr, 8));
10784                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10785                 if (_ptr_attribute_name) {
10786                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10787                 } else {
10788                         r->attribute_name = NULL;
10789                 }
10790                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
10791                 if (_ptr_object_dn) {
10792                         NDR_PULL_ALLOC(ndr, r->object_dn);
10793                 } else {
10794                         r->object_dn = NULL;
10795                 }
10796                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
10797                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
10798                 if (_ptr_binary) {
10799                         NDR_PULL_ALLOC(ndr, r->binary);
10800                 } else {
10801                         r->binary = NULL;
10802                 }
10803                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
10804                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
10805                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10806                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10807                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10808                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10809                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10810                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10811         }
10812         if (ndr_flags & NDR_BUFFERS) {
10813                 if (r->attribute_name) {
10814                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10815                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10816                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10817                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10818                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10819                                 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));
10820                         }
10821                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10822                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10823                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10824                 }
10825                 if (r->object_dn) {
10826                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10827                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
10828                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
10829                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
10830                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
10831                                 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));
10832                         }
10833                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
10834                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
10835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
10836                 }
10837                 if (r->binary) {
10838                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
10839                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
10840                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
10841                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
10842                 }
10843         }
10844         return NDR_ERR_SUCCESS;
10845 }
10846
10847 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData *r)
10848 {
10849         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData");
10850         ndr->depth++;
10851         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10852         ndr->depth++;
10853         if (r->attribute_name) {
10854                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10855         }
10856         ndr->depth--;
10857         ndr_print_ptr(ndr, "object_dn", r->object_dn);
10858         ndr->depth++;
10859         if (r->object_dn) {
10860                 ndr_print_string(ndr, "object_dn", r->object_dn);
10861         }
10862         ndr->depth--;
10863         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);
10864         ndr_print_ptr(ndr, "binary", r->binary);
10865         ndr->depth++;
10866         if (r->binary) {
10867                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
10868         }
10869         ndr->depth--;
10870         ndr_print_NTTIME(ndr, "deleted", r->deleted);
10871         ndr_print_NTTIME(ndr, "created", r->created);
10872         ndr_print_uint32(ndr, "version", r->version);
10873         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10874         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10875         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10876         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10877         ndr->depth--;
10878 }
10879
10880 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10881 {
10882         uint32_t cntr_array_0;
10883         if (ndr_flags & NDR_SCALARS) {
10884                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10885                 NDR_CHECK(ndr_push_align(ndr, 8));
10886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10887                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
10888                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10889                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10890                 }
10891                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10892         }
10893         if (ndr_flags & NDR_BUFFERS) {
10894                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10895                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10896                 }
10897         }
10898         return NDR_ERR_SUCCESS;
10899 }
10900
10901 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10902 {
10903         uint32_t cntr_array_0;
10904         TALLOC_CTX *_mem_save_array_0;
10905         if (ndr_flags & NDR_SCALARS) {
10906                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10907                 NDR_CHECK(ndr_pull_align(ndr, 8));
10908                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
10910                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10911                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10912                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10913                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10914                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10915                 }
10916                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10917                 if (r->array) {
10918                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10919                 }
10920                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10921         }
10922         if (ndr_flags & NDR_BUFFERS) {
10923                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10924                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10925                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10926                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10927                 }
10928                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10929         }
10930         return NDR_ERR_SUCCESS;
10931 }
10932
10933 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10934 {
10935         uint32_t cntr_array_0;
10936         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaDataCtr");
10937         ndr->depth++;
10938         ndr_print_uint32(ndr, "count", r->count);
10939         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
10940         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10941         ndr->depth++;
10942         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10943                 char *idx_0=NULL;
10944                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10945                         ndr_print_drsuapi_DsReplicaAttrValMetaData(ndr, "array", &r->array[cntr_array_0]);
10946                         free(idx_0);
10947                 }
10948         }
10949         ndr->depth--;
10950         ndr->depth--;
10951 }
10952
10953 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2Ctr *r)
10954 {
10955         uint32_t cntr_array_0;
10956         if (ndr_flags & NDR_SCALARS) {
10957                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10958                 NDR_CHECK(ndr_push_align(ndr, 8));
10959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
10961                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10962                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10963                 }
10964                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10965         }
10966         if (ndr_flags & NDR_BUFFERS) {
10967         }
10968         return NDR_ERR_SUCCESS;
10969 }
10970
10971 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
10972 {
10973         uint32_t cntr_array_0;
10974         TALLOC_CTX *_mem_save_array_0;
10975         if (ndr_flags & NDR_SCALARS) {
10976                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10977                 NDR_CHECK(ndr_pull_align(ndr, 8));
10978                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10979                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
10980                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10981                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10982                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10983                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10984                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10985                 }
10986                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10987                 if (r->array) {
10988                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10989                 }
10990                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10991         }
10992         if (ndr_flags & NDR_BUFFERS) {
10993         }
10994         return NDR_ERR_SUCCESS;
10995 }
10996
10997 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2Ctr *r)
10998 {
10999         uint32_t cntr_array_0;
11000         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2Ctr");
11001         ndr->depth++;
11002         ndr_print_uint32(ndr, "count", r->count);
11003         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11004         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11005         ndr->depth++;
11006         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11007                 char *idx_0=NULL;
11008                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11009                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "array", &r->array[cntr_array_0]);
11010                         free(idx_0);
11011                 }
11012         }
11013         ndr->depth--;
11014         ndr->depth--;
11015 }
11016
11017 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3 *r)
11018 {
11019         if (ndr_flags & NDR_SCALARS) {
11020                 NDR_CHECK(ndr_push_align(ndr, 8));
11021                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11022                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
11023                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
11024                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
11025                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11026         }
11027         if (ndr_flags & NDR_BUFFERS) {
11028                 if (r->source_dsa_obj_dn) {
11029                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11030                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11031                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11032                         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));
11033                 }
11034         }
11035         return NDR_ERR_SUCCESS;
11036 }
11037
11038 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
11039 {
11040         uint32_t _ptr_source_dsa_obj_dn;
11041         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
11042         if (ndr_flags & NDR_SCALARS) {
11043                 NDR_CHECK(ndr_pull_align(ndr, 8));
11044                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11045                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
11046                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
11047                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
11048                 if (_ptr_source_dsa_obj_dn) {
11049                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
11050                 } else {
11051                         r->source_dsa_obj_dn = NULL;
11052                 }
11053                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11054         }
11055         if (ndr_flags & NDR_BUFFERS) {
11056                 if (r->source_dsa_obj_dn) {
11057                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11058                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
11059                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
11060                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
11061                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
11062                                 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));
11063                         }
11064                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
11065                         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));
11066                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
11067                 }
11068         }
11069         return NDR_ERR_SUCCESS;
11070 }
11071
11072 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3 *r)
11073 {
11074         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3");
11075         ndr->depth++;
11076         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
11077         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
11078         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
11079         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11080         ndr->depth++;
11081         if (r->source_dsa_obj_dn) {
11082                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11083         }
11084         ndr->depth--;
11085         ndr->depth--;
11086 }
11087
11088 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3Ctr *r)
11089 {
11090         uint32_t cntr_array_0;
11091         if (ndr_flags & NDR_SCALARS) {
11092                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11093                 NDR_CHECK(ndr_push_align(ndr, 8));
11094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11096                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11097                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11098                 }
11099                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11100         }
11101         if (ndr_flags & NDR_BUFFERS) {
11102                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11103                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11104                 }
11105         }
11106         return NDR_ERR_SUCCESS;
11107 }
11108
11109 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
11110 {
11111         uint32_t cntr_array_0;
11112         TALLOC_CTX *_mem_save_array_0;
11113         if (ndr_flags & NDR_SCALARS) {
11114                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11115                 NDR_CHECK(ndr_pull_align(ndr, 8));
11116                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11117                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11118                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11119                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11120                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11121                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11122                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11123                 }
11124                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11125                 if (r->array) {
11126                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11127                 }
11128                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11129         }
11130         if (ndr_flags & NDR_BUFFERS) {
11131                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11132                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11133                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11134                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11135                 }
11136                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11137         }
11138         return NDR_ERR_SUCCESS;
11139 }
11140
11141 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3Ctr *r)
11142 {
11143         uint32_t cntr_array_0;
11144         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3Ctr");
11145         ndr->depth++;
11146         ndr_print_uint32(ndr, "count", r->count);
11147         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11148         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11149         ndr->depth++;
11150         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11151                 char *idx_0=NULL;
11152                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11153                         ndr_print_drsuapi_DsReplicaCursor3(ndr, "array", &r->array[cntr_array_0]);
11154                         free(idx_0);
11155                 }
11156         }
11157         ndr->depth--;
11158         ndr->depth--;
11159 }
11160
11161 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2 *r)
11162 {
11163         if (ndr_flags & NDR_SCALARS) {
11164                 NDR_CHECK(ndr_push_align(ndr, 8));
11165                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11167                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11168                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11169                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11170                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11171                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11172                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11173         }
11174         if (ndr_flags & NDR_BUFFERS) {
11175                 if (r->attribute_name) {
11176                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11177                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11178                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11179                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11180                 }
11181                 if (r->originating_dsa_dn) {
11182                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11183                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11184                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11185                         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));
11186                 }
11187         }
11188         return NDR_ERR_SUCCESS;
11189 }
11190
11191 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
11192 {
11193         uint32_t _ptr_attribute_name;
11194         TALLOC_CTX *_mem_save_attribute_name_0;
11195         uint32_t _ptr_originating_dsa_dn;
11196         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11197         if (ndr_flags & NDR_SCALARS) {
11198                 NDR_CHECK(ndr_pull_align(ndr, 8));
11199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11200                 if (_ptr_attribute_name) {
11201                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11202                 } else {
11203                         r->attribute_name = NULL;
11204                 }
11205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11206                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11207                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11208                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11209                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11210                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11211                 if (_ptr_originating_dsa_dn) {
11212                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11213                 } else {
11214                         r->originating_dsa_dn = NULL;
11215                 }
11216                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11217         }
11218         if (ndr_flags & NDR_BUFFERS) {
11219                 if (r->attribute_name) {
11220                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11221                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11222                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11223                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11224                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11225                                 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));
11226                         }
11227                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11228                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11229                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11230                 }
11231                 if (r->originating_dsa_dn) {
11232                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11233                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11234                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11235                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11236                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11237                                 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));
11238                         }
11239                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11240                         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));
11241                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11242                 }
11243         }
11244         return NDR_ERR_SUCCESS;
11245 }
11246
11247 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2 *r)
11248 {
11249         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2");
11250         ndr->depth++;
11251         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11252         ndr->depth++;
11253         if (r->attribute_name) {
11254                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11255         }
11256         ndr->depth--;
11257         ndr_print_uint32(ndr, "version", r->version);
11258         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11259         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11260         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11261         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11262         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11263         ndr->depth++;
11264         if (r->originating_dsa_dn) {
11265                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11266         }
11267         ndr->depth--;
11268         ndr->depth--;
11269 }
11270
11271 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11272 {
11273         uint32_t cntr_array_0;
11274         if (ndr_flags & NDR_SCALARS) {
11275                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11276                 NDR_CHECK(ndr_push_align(ndr, 8));
11277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11279                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11280                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11281                 }
11282                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11283         }
11284         if (ndr_flags & NDR_BUFFERS) {
11285                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11286                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11287                 }
11288         }
11289         return NDR_ERR_SUCCESS;
11290 }
11291
11292 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11293 {
11294         uint32_t cntr_array_0;
11295         TALLOC_CTX *_mem_save_array_0;
11296         if (ndr_flags & NDR_SCALARS) {
11297                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11298                 NDR_CHECK(ndr_pull_align(ndr, 8));
11299                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11300                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11301                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11302                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11303                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11304                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11305                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11306                 }
11307                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11308                 if (r->array) {
11309                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11310                 }
11311                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11312         }
11313         if (ndr_flags & NDR_BUFFERS) {
11314                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11315                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11316                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11317                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11318                 }
11319                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11320         }
11321         return NDR_ERR_SUCCESS;
11322 }
11323
11324 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11325 {
11326         uint32_t cntr_array_0;
11327         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2Ctr");
11328         ndr->depth++;
11329         ndr_print_uint32(ndr, "count", r->count);
11330         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11331         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11332         ndr->depth++;
11333         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11334                 char *idx_0=NULL;
11335                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11336                         ndr_print_drsuapi_DsReplicaObjMetaData2(ndr, "array", &r->array[cntr_array_0]);
11337                         free(idx_0);
11338                 }
11339         }
11340         ndr->depth--;
11341         ndr->depth--;
11342 }
11343
11344 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11345 {
11346         if (ndr_flags & NDR_SCALARS) {
11347                 NDR_CHECK(ndr_push_align(ndr, 8));
11348                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11349                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11351                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11352                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11353                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11354                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11355                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11356                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11357                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11358                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11360                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11361         }
11362         if (ndr_flags & NDR_BUFFERS) {
11363                 if (r->attribute_name) {
11364                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11365                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11366                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11367                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11368                 }
11369                 if (r->object_dn) {
11370                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11371                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11372                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11373                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11374                 }
11375                 if (r->binary) {
11376                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11377                 }
11378                 if (r->originating_dsa_dn) {
11379                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11380                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11381                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11382                         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));
11383                 }
11384         }
11385         return NDR_ERR_SUCCESS;
11386 }
11387
11388 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
11389 {
11390         uint32_t _ptr_attribute_name;
11391         TALLOC_CTX *_mem_save_attribute_name_0;
11392         uint32_t _ptr_object_dn;
11393         TALLOC_CTX *_mem_save_object_dn_0;
11394         uint32_t _ptr_binary;
11395         TALLOC_CTX *_mem_save_binary_0;
11396         uint32_t _ptr_originating_dsa_dn;
11397         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11398         if (ndr_flags & NDR_SCALARS) {
11399                 NDR_CHECK(ndr_pull_align(ndr, 8));
11400                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11401                 if (_ptr_attribute_name) {
11402                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11403                 } else {
11404                         r->attribute_name = NULL;
11405                 }
11406                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11407                 if (_ptr_object_dn) {
11408                         NDR_PULL_ALLOC(ndr, r->object_dn);
11409                 } else {
11410                         r->object_dn = NULL;
11411                 }
11412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11413                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11414                 if (_ptr_binary) {
11415                         NDR_PULL_ALLOC(ndr, r->binary);
11416                 } else {
11417                         r->binary = NULL;
11418                 }
11419                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11420                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11422                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11423                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11424                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11425                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11426                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11427                 if (_ptr_originating_dsa_dn) {
11428                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11429                 } else {
11430                         r->originating_dsa_dn = NULL;
11431                 }
11432                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11433         }
11434         if (ndr_flags & NDR_BUFFERS) {
11435                 if (r->attribute_name) {
11436                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11437                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11438                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11439                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11440                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11441                                 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));
11442                         }
11443                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11444                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11445                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11446                 }
11447                 if (r->object_dn) {
11448                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11449                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11450                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11451                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11452                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11453                                 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));
11454                         }
11455                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11456                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11457                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11458                 }
11459                 if (r->binary) {
11460                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11461                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11462                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11463                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11464                 }
11465                 if (r->originating_dsa_dn) {
11466                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11467                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11468                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11469                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11470                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11471                                 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));
11472                         }
11473                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11474                         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));
11475                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11476                 }
11477         }
11478         return NDR_ERR_SUCCESS;
11479 }
11480
11481 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11482 {
11483         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2");
11484         ndr->depth++;
11485         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11486         ndr->depth++;
11487         if (r->attribute_name) {
11488                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11489         }
11490         ndr->depth--;
11491         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11492         ndr->depth++;
11493         if (r->object_dn) {
11494                 ndr_print_string(ndr, "object_dn", r->object_dn);
11495         }
11496         ndr->depth--;
11497         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);
11498         ndr_print_ptr(ndr, "binary", r->binary);
11499         ndr->depth++;
11500         if (r->binary) {
11501                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11502         }
11503         ndr->depth--;
11504         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11505         ndr_print_NTTIME(ndr, "created", r->created);
11506         ndr_print_uint32(ndr, "version", r->version);
11507         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11508         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11509         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11510         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11511         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11512         ndr->depth++;
11513         if (r->originating_dsa_dn) {
11514                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11515         }
11516         ndr->depth--;
11517         ndr->depth--;
11518 }
11519
11520 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11521 {
11522         uint32_t cntr_array_0;
11523         if (ndr_flags & NDR_SCALARS) {
11524                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11525                 NDR_CHECK(ndr_push_align(ndr, 8));
11526                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11528                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11529                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11530                 }
11531                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11532         }
11533         if (ndr_flags & NDR_BUFFERS) {
11534                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11535                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11536                 }
11537         }
11538         return NDR_ERR_SUCCESS;
11539 }
11540
11541 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11542 {
11543         uint32_t cntr_array_0;
11544         TALLOC_CTX *_mem_save_array_0;
11545         if (ndr_flags & NDR_SCALARS) {
11546                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11547                 NDR_CHECK(ndr_pull_align(ndr, 8));
11548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11550                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11551                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11552                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11553                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11554                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11555                 }
11556                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11557                 if (r->array) {
11558                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11559                 }
11560                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11561         }
11562         if (ndr_flags & NDR_BUFFERS) {
11563                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11564                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11565                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11566                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11567                 }
11568                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11569         }
11570         return NDR_ERR_SUCCESS;
11571 }
11572
11573 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11574 {
11575         uint32_t cntr_array_0;
11576         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2Ctr");
11577         ndr->depth++;
11578         ndr_print_uint32(ndr, "count", r->count);
11579         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11580         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11581         ndr->depth++;
11582         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11583                 char *idx_0=NULL;
11584                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11585                         ndr_print_drsuapi_DsReplicaAttrValMetaData2(ndr, "array", &r->array[cntr_array_0]);
11586                         free(idx_0);
11587                 }
11588         }
11589         ndr->depth--;
11590         ndr->depth--;
11591 }
11592
11593 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04 *r)
11594 {
11595         if (ndr_flags & NDR_SCALARS) {
11596                 NDR_CHECK(ndr_push_align(ndr, 8));
11597                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u1));
11598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11600                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11601                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->bind_time));
11602                 {
11603                         uint32_t _flags_save_ipv4address = ndr->flags;
11604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11605                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
11606                         ndr->flags = _flags_save_ipv4address;
11607                 }
11608                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11609                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11610         }
11611         if (ndr_flags & NDR_BUFFERS) {
11612         }
11613         return NDR_ERR_SUCCESS;
11614 }
11615
11616 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04 *r)
11617 {
11618         if (ndr_flags & NDR_SCALARS) {
11619                 NDR_CHECK(ndr_pull_align(ndr, 8));
11620                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u1));
11621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11622                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11623                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11624                 NDR_CHECK(ndr_pull_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_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
11629                         ndr->flags = _flags_save_ipv4address;
11630                 }
11631                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11632                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11633         }
11634         if (ndr_flags & NDR_BUFFERS) {
11635         }
11636         return NDR_ERR_SUCCESS;
11637 }
11638
11639 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04 *r)
11640 {
11641         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04");
11642         ndr->depth++;
11643         ndr_print_hyper(ndr, "u1", r->u1);
11644         ndr_print_uint32(ndr, "u2", r->u2);
11645         ndr_print_uint32(ndr, "u3", r->u3);
11646         ndr_print_GUID(ndr, "bind_guid", &r->bind_guid);
11647         ndr_print_NTTIME_1sec(ndr, "bind_time", r->bind_time);
11648         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
11649         ndr_print_uint32(ndr, "u5", r->u5);
11650         ndr->depth--;
11651 }
11652
11653 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04Ctr *r)
11654 {
11655         uint32_t cntr_array_0;
11656         if (ndr_flags & NDR_SCALARS) {
11657                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11658                 NDR_CHECK(ndr_push_align(ndr, 8));
11659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11660                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11661                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11662                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11663                 }
11664                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11665         }
11666         if (ndr_flags & NDR_BUFFERS) {
11667         }
11668         return NDR_ERR_SUCCESS;
11669 }
11670
11671 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
11672 {
11673         uint32_t cntr_array_0;
11674         TALLOC_CTX *_mem_save_array_0;
11675         if (ndr_flags & NDR_SCALARS) {
11676                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11677                 NDR_CHECK(ndr_pull_align(ndr, 8));
11678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11679                 if (r->count > 10000) {
11680                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11681                 }
11682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11683                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11684                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11685                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11686                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11687                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11688                 }
11689                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11690                 if (r->array) {
11691                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11692                 }
11693                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11694         }
11695         if (ndr_flags & NDR_BUFFERS) {
11696         }
11697         return NDR_ERR_SUCCESS;
11698 }
11699
11700 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04Ctr *r)
11701 {
11702         uint32_t cntr_array_0;
11703         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04Ctr");
11704         ndr->depth++;
11705         ndr_print_uint32(ndr, "count", r->count);
11706         ndr_print_uint32(ndr, "reserved", r->reserved);
11707         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11708         ndr->depth++;
11709         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11710                 char *idx_0=NULL;
11711                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11712                         ndr_print_drsuapi_DsReplicaConnection04(ndr, "array", &r->array[cntr_array_0]);
11713                         free(idx_0);
11714                 }
11715         }
11716         ndr->depth--;
11717         ndr->depth--;
11718 }
11719
11720 static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06 *r)
11721 {
11722         if (ndr_flags & NDR_SCALARS) {
11723                 NDR_CHECK(ndr_push_align(ndr, 8));
11724                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str1));
11725                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u1));
11726                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11727                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11728                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u4));
11729                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11730                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
11731                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
11732                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11733         }
11734         if (ndr_flags & NDR_BUFFERS) {
11735                 if (r->str1) {
11736                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11737                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11738                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11739                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11740                 }
11741         }
11742         return NDR_ERR_SUCCESS;
11743 }
11744
11745 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
11746 {
11747         uint32_t _ptr_str1;
11748         TALLOC_CTX *_mem_save_str1_0;
11749         if (ndr_flags & NDR_SCALARS) {
11750                 NDR_CHECK(ndr_pull_align(ndr, 8));
11751                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str1));
11752                 if (_ptr_str1) {
11753                         NDR_PULL_ALLOC(ndr, r->str1);
11754                 } else {
11755                         r->str1 = NULL;
11756                 }
11757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
11758                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11759                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11760                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u4));
11761                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11762                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
11763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
11764                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11765         }
11766         if (ndr_flags & NDR_BUFFERS) {
11767                 if (r->str1) {
11768                         _mem_save_str1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11769                         NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
11770                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
11771                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
11772                         if (ndr_get_array_length(ndr, &r->str1) > ndr_get_array_size(ndr, &r->str1)) {
11773                                 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));
11774                         }
11775                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t)));
11776                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t), CH_UTF16));
11777                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
11778                 }
11779         }
11780         return NDR_ERR_SUCCESS;
11781 }
11782
11783 _PUBLIC_ void ndr_print_drsuapi_DsReplica06(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06 *r)
11784 {
11785         ndr_print_struct(ndr, name, "drsuapi_DsReplica06");
11786         ndr->depth++;
11787         ndr_print_ptr(ndr, "str1", r->str1);
11788         ndr->depth++;
11789         if (r->str1) {
11790                 ndr_print_string(ndr, "str1", r->str1);
11791         }
11792         ndr->depth--;
11793         ndr_print_uint32(ndr, "u1", r->u1);
11794         ndr_print_uint32(ndr, "u2", r->u2);
11795         ndr_print_uint32(ndr, "u3", r->u3);
11796         ndr_print_uint32(ndr, "u4", r->u4);
11797         ndr_print_uint32(ndr, "u5", r->u5);
11798         ndr_print_hyper(ndr, "u6", r->u6);
11799         ndr_print_uint32(ndr, "u7", r->u7);
11800         ndr->depth--;
11801 }
11802
11803 static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06Ctr *r)
11804 {
11805         uint32_t cntr_array_0;
11806         if (ndr_flags & NDR_SCALARS) {
11807                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11808                 NDR_CHECK(ndr_push_align(ndr, 8));
11809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11811                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11812                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11813                 }
11814                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11815         }
11816         if (ndr_flags & NDR_BUFFERS) {
11817                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11818                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11819                 }
11820         }
11821         return NDR_ERR_SUCCESS;
11822 }
11823
11824 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *r)
11825 {
11826         uint32_t cntr_array_0;
11827         TALLOC_CTX *_mem_save_array_0;
11828         if (ndr_flags & NDR_SCALARS) {
11829                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11830                 NDR_CHECK(ndr_pull_align(ndr, 8));
11831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11832                 if (r->count > 256) {
11833                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11834                 }
11835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11836                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11837                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11838                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11839                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11840                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11841                 }
11842                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11843                 if (r->array) {
11844                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11845                 }
11846                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11847         }
11848         if (ndr_flags & NDR_BUFFERS) {
11849                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11850                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11851                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11852                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11853                 }
11854                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11855         }
11856         return NDR_ERR_SUCCESS;
11857 }
11858
11859 _PUBLIC_ void ndr_print_drsuapi_DsReplica06Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06Ctr *r)
11860 {
11861         uint32_t cntr_array_0;
11862         ndr_print_struct(ndr, name, "drsuapi_DsReplica06Ctr");
11863         ndr->depth++;
11864         ndr_print_uint32(ndr, "count", r->count);
11865         ndr_print_uint32(ndr, "reserved", r->reserved);
11866         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11867         ndr->depth++;
11868         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11869                 char *idx_0=NULL;
11870                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11871                         ndr_print_drsuapi_DsReplica06(ndr, "array", &r->array[cntr_array_0]);
11872                         free(idx_0);
11873                 }
11874         }
11875         ndr->depth--;
11876         ndr->depth--;
11877 }
11878
11879 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaInfo *r)
11880 {
11881         if (ndr_flags & NDR_SCALARS) {
11882                 int level = ndr_push_get_switch_value(ndr, r);
11883                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
11884                 NDR_CHECK(ndr_push_union_align(ndr, 5));
11885                 switch (level) {
11886                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
11887                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
11888                         break; }
11889
11890                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
11891                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors));
11892                         break; }
11893
11894                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
11895                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata));
11896                         break; }
11897
11898                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
11899                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connectfailures));
11900                         break; }
11901
11902                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
11903                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linkfailures));
11904                         break; }
11905
11906                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
11907                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pendingops));
11908                         break; }
11909
11910                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
11911                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata));
11912                         break; }
11913
11914                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
11915                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors2));
11916                         break; }
11917
11918                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
11919                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors3));
11920                         break; }
11921
11922                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
11923                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata2));
11924                         break; }
11925
11926                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
11927                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata2));
11928                         break; }
11929
11930                         case DRSUAPI_DS_REPLICA_INFO_REPSTO: {
11931                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->repsto));
11932                         break; }
11933
11934                         case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS: {
11935                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->clientctx));
11936                         break; }
11937
11938                         case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1: {
11939                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->udv1));
11940                         break; }
11941
11942                         case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS: {
11943                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->srvoutgoingcalls));
11944                         break; }
11945
11946                         default:
11947                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
11948                 }
11949         }
11950         if (ndr_flags & NDR_BUFFERS) {
11951                 int level = ndr_push_get_switch_value(ndr, r);
11952                 switch (level) {
11953                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
11954                                 if (r->neighbours) {
11955                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
11956                                 }
11957                         break;
11958
11959                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
11960                                 if (r->cursors) {
11961                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
11962                                 }
11963                         break;
11964
11965                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
11966                                 if (r->objmetadata) {
11967                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
11968                                 }
11969                         break;
11970
11971                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
11972                                 if (r->connectfailures) {
11973                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
11974                                 }
11975                         break;
11976
11977                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
11978                                 if (r->linkfailures) {
11979                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
11980                                 }
11981                         break;
11982
11983                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
11984                                 if (r->pendingops) {
11985                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
11986                                 }
11987                         break;
11988
11989                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
11990                                 if (r->attrvalmetadata) {
11991                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
11992                                 }
11993                         break;
11994
11995                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
11996                                 if (r->cursors2) {
11997                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
11998                                 }
11999                         break;
12000
12001                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12002                                 if (r->cursors3) {
12003                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12004                                 }
12005                         break;
12006
12007                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12008                                 if (r->objmetadata2) {
12009                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12010                                 }
12011                         break;
12012
12013                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12014                                 if (r->attrvalmetadata2) {
12015                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12016                                 }
12017                         break;
12018
12019                         case DRSUAPI_DS_REPLICA_INFO_REPSTO:
12020                                 if (r->repsto) {
12021                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->repsto));
12022                                 }
12023                         break;
12024
12025                         case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS:
12026                                 if (r->clientctx) {
12027                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->clientctx));
12028                                 }
12029                         break;
12030
12031                         case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1:
12032                                 if (r->udv1) {
12033                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->udv1));
12034                                 }
12035                         break;
12036
12037                         case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS:
12038                                 if (r->srvoutgoingcalls) {
12039                                         NDR_CHECK(ndr_push_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->srvoutgoingcalls));
12040                                 }
12041                         break;
12042
12043                         default:
12044                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12045                 }
12046         }
12047         return NDR_ERR_SUCCESS;
12048 }
12049
12050 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaInfo *r)
12051 {
12052         int level;
12053         uint32_t _level;
12054         TALLOC_CTX *_mem_save_neighbours_0;
12055         TALLOC_CTX *_mem_save_cursors_0;
12056         TALLOC_CTX *_mem_save_objmetadata_0;
12057         TALLOC_CTX *_mem_save_connectfailures_0;
12058         TALLOC_CTX *_mem_save_linkfailures_0;
12059         TALLOC_CTX *_mem_save_pendingops_0;
12060         TALLOC_CTX *_mem_save_attrvalmetadata_0;
12061         TALLOC_CTX *_mem_save_cursors2_0;
12062         TALLOC_CTX *_mem_save_cursors3_0;
12063         TALLOC_CTX *_mem_save_objmetadata2_0;
12064         TALLOC_CTX *_mem_save_attrvalmetadata2_0;
12065         TALLOC_CTX *_mem_save_repsto_0;
12066         TALLOC_CTX *_mem_save_clientctx_0;
12067         TALLOC_CTX *_mem_save_udv1_0;
12068         TALLOC_CTX *_mem_save_srvoutgoingcalls_0;
12069         level = ndr_pull_get_switch_value(ndr, r);
12070         if (ndr_flags & NDR_SCALARS) {
12071                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12072                 if (_level != level) {
12073                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12074                 }
12075                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12076                 switch (level) {
12077                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12078                                 uint32_t _ptr_neighbours;
12079                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
12080                                 if (_ptr_neighbours) {
12081                                         NDR_PULL_ALLOC(ndr, r->neighbours);
12082                                 } else {
12083                                         r->neighbours = NULL;
12084                                 }
12085                         break; }
12086
12087                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12088                                 uint32_t _ptr_cursors;
12089                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
12090                                 if (_ptr_cursors) {
12091                                         NDR_PULL_ALLOC(ndr, r->cursors);
12092                                 } else {
12093                                         r->cursors = NULL;
12094                                 }
12095                         break; }
12096
12097                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12098                                 uint32_t _ptr_objmetadata;
12099                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
12100                                 if (_ptr_objmetadata) {
12101                                         NDR_PULL_ALLOC(ndr, r->objmetadata);
12102                                 } else {
12103                                         r->objmetadata = NULL;
12104                                 }
12105                         break; }
12106
12107                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12108                                 uint32_t _ptr_connectfailures;
12109                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
12110                                 if (_ptr_connectfailures) {
12111                                         NDR_PULL_ALLOC(ndr, r->connectfailures);
12112                                 } else {
12113                                         r->connectfailures = NULL;
12114                                 }
12115                         break; }
12116
12117                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12118                                 uint32_t _ptr_linkfailures;
12119                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
12120                                 if (_ptr_linkfailures) {
12121                                         NDR_PULL_ALLOC(ndr, r->linkfailures);
12122                                 } else {
12123                                         r->linkfailures = NULL;
12124                                 }
12125                         break; }
12126
12127                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12128                                 uint32_t _ptr_pendingops;
12129                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
12130                                 if (_ptr_pendingops) {
12131                                         NDR_PULL_ALLOC(ndr, r->pendingops);
12132                                 } else {
12133                                         r->pendingops = NULL;
12134                                 }
12135                         break; }
12136
12137                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12138                                 uint32_t _ptr_attrvalmetadata;
12139                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
12140                                 if (_ptr_attrvalmetadata) {
12141                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
12142                                 } else {
12143                                         r->attrvalmetadata = NULL;
12144                                 }
12145                         break; }
12146
12147                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12148                                 uint32_t _ptr_cursors2;
12149                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
12150                                 if (_ptr_cursors2) {
12151                                         NDR_PULL_ALLOC(ndr, r->cursors2);
12152                                 } else {
12153                                         r->cursors2 = NULL;
12154                                 }
12155                         break; }
12156
12157                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12158                                 uint32_t _ptr_cursors3;
12159                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
12160                                 if (_ptr_cursors3) {
12161                                         NDR_PULL_ALLOC(ndr, r->cursors3);
12162                                 } else {
12163                                         r->cursors3 = NULL;
12164                                 }
12165                         break; }
12166
12167                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12168                                 uint32_t _ptr_objmetadata2;
12169                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
12170                                 if (_ptr_objmetadata2) {
12171                                         NDR_PULL_ALLOC(ndr, r->objmetadata2);
12172                                 } else {
12173                                         r->objmetadata2 = NULL;
12174                                 }
12175                         break; }
12176
12177                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12178                                 uint32_t _ptr_attrvalmetadata2;
12179                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
12180                                 if (_ptr_attrvalmetadata2) {
12181                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
12182                                 } else {
12183                                         r->attrvalmetadata2 = NULL;
12184                                 }
12185                         break; }
12186
12187                         case DRSUAPI_DS_REPLICA_INFO_REPSTO: {
12188                                 uint32_t _ptr_repsto;
12189                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_repsto));
12190                                 if (_ptr_repsto) {
12191                                         NDR_PULL_ALLOC(ndr, r->repsto);
12192                                 } else {
12193                                         r->repsto = NULL;
12194                                 }
12195                         break; }
12196
12197                         case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS: {
12198                                 uint32_t _ptr_clientctx;
12199                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_clientctx));
12200                                 if (_ptr_clientctx) {
12201                                         NDR_PULL_ALLOC(ndr, r->clientctx);
12202                                 } else {
12203                                         r->clientctx = NULL;
12204                                 }
12205                         break; }
12206
12207                         case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1: {
12208                                 uint32_t _ptr_udv1;
12209                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_udv1));
12210                                 if (_ptr_udv1) {
12211                                         NDR_PULL_ALLOC(ndr, r->udv1);
12212                                 } else {
12213                                         r->udv1 = NULL;
12214                                 }
12215                         break; }
12216
12217                         case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS: {
12218                                 uint32_t _ptr_srvoutgoingcalls;
12219                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_srvoutgoingcalls));
12220                                 if (_ptr_srvoutgoingcalls) {
12221                                         NDR_PULL_ALLOC(ndr, r->srvoutgoingcalls);
12222                                 } else {
12223                                         r->srvoutgoingcalls = NULL;
12224                                 }
12225                         break; }
12226
12227                         default:
12228                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12229                 }
12230         }
12231         if (ndr_flags & NDR_BUFFERS) {
12232                 switch (level) {
12233                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12234                                 if (r->neighbours) {
12235                                         _mem_save_neighbours_0 = NDR_PULL_GET_MEM_CTX(ndr);
12236                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours, 0);
12237                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12238                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours_0, 0);
12239                                 }
12240                         break;
12241
12242                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12243                                 if (r->cursors) {
12244                                         _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
12245                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
12246                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12247                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
12248                                 }
12249                         break;
12250
12251                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12252                                 if (r->objmetadata) {
12253                                         _mem_save_objmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12254                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata, 0);
12255                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12256                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata_0, 0);
12257                                 }
12258                         break;
12259
12260                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12261                                 if (r->connectfailures) {
12262                                         _mem_save_connectfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12263                                         NDR_PULL_SET_MEM_CTX(ndr, r->connectfailures, 0);
12264                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12265                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connectfailures_0, 0);
12266                                 }
12267                         break;
12268
12269                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12270                                 if (r->linkfailures) {
12271                                         _mem_save_linkfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12272                                         NDR_PULL_SET_MEM_CTX(ndr, r->linkfailures, 0);
12273                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12274                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linkfailures_0, 0);
12275                                 }
12276                         break;
12277
12278                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12279                                 if (r->pendingops) {
12280                                         _mem_save_pendingops_0 = NDR_PULL_GET_MEM_CTX(ndr);
12281                                         NDR_PULL_SET_MEM_CTX(ndr, r->pendingops, 0);
12282                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12283                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pendingops_0, 0);
12284                                 }
12285                         break;
12286
12287                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12288                                 if (r->attrvalmetadata) {
12289                                         _mem_save_attrvalmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12290                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata, 0);
12291                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12292                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata_0, 0);
12293                                 }
12294                         break;
12295
12296                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12297                                 if (r->cursors2) {
12298                                         _mem_save_cursors2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12299                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors2, 0);
12300                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12301                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors2_0, 0);
12302                                 }
12303                         break;
12304
12305                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12306                                 if (r->cursors3) {
12307                                         _mem_save_cursors3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12308                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors3, 0);
12309                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12310                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors3_0, 0);
12311                                 }
12312                         break;
12313
12314                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12315                                 if (r->objmetadata2) {
12316                                         _mem_save_objmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12317                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata2, 0);
12318                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12319                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata2_0, 0);
12320                                 }
12321                         break;
12322
12323                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12324                                 if (r->attrvalmetadata2) {
12325                                         _mem_save_attrvalmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12326                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata2, 0);
12327                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12328                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata2_0, 0);
12329                                 }
12330                         break;
12331
12332                         case DRSUAPI_DS_REPLICA_INFO_REPSTO:
12333                                 if (r->repsto) {
12334                                         _mem_save_repsto_0 = NDR_PULL_GET_MEM_CTX(ndr);
12335                                         NDR_PULL_SET_MEM_CTX(ndr, r->repsto, 0);
12336                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->repsto));
12337                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_repsto_0, 0);
12338                                 }
12339                         break;
12340
12341                         case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS:
12342                                 if (r->clientctx) {
12343                                         _mem_save_clientctx_0 = NDR_PULL_GET_MEM_CTX(ndr);
12344                                         NDR_PULL_SET_MEM_CTX(ndr, r->clientctx, 0);
12345                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->clientctx));
12346                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_clientctx_0, 0);
12347                                 }
12348                         break;
12349
12350                         case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1:
12351                                 if (r->udv1) {
12352                                         _mem_save_udv1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12353                                         NDR_PULL_SET_MEM_CTX(ndr, r->udv1, 0);
12354                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->udv1));
12355                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_udv1_0, 0);
12356                                 }
12357                         break;
12358
12359                         case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS:
12360                                 if (r->srvoutgoingcalls) {
12361                                         _mem_save_srvoutgoingcalls_0 = NDR_PULL_GET_MEM_CTX(ndr);
12362                                         NDR_PULL_SET_MEM_CTX(ndr, r->srvoutgoingcalls, 0);
12363                                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->srvoutgoingcalls));
12364                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_srvoutgoingcalls_0, 0);
12365                                 }
12366                         break;
12367
12368                         default:
12369                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12370                 }
12371         }
12372         return NDR_ERR_SUCCESS;
12373 }
12374
12375 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaInfo *r)
12376 {
12377         int level;
12378         level = ndr_print_get_switch_value(ndr, r);
12379         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaInfo");
12380         switch (level) {
12381                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12382                         ndr_print_ptr(ndr, "neighbours", r->neighbours);
12383                         ndr->depth++;
12384                         if (r->neighbours) {
12385                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours", r->neighbours);
12386                         }
12387                         ndr->depth--;
12388                 break;
12389
12390                 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12391                         ndr_print_ptr(ndr, "cursors", r->cursors);
12392                         ndr->depth++;
12393                         if (r->cursors) {
12394                                 ndr_print_drsuapi_DsReplicaCursorCtr(ndr, "cursors", r->cursors);
12395                         }
12396                         ndr->depth--;
12397                 break;
12398
12399                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12400                         ndr_print_ptr(ndr, "objmetadata", r->objmetadata);
12401                         ndr->depth++;
12402                         if (r->objmetadata) {
12403                                 ndr_print_drsuapi_DsReplicaObjMetaDataCtr(ndr, "objmetadata", r->objmetadata);
12404                         }
12405                         ndr->depth--;
12406                 break;
12407
12408                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12409                         ndr_print_ptr(ndr, "connectfailures", r->connectfailures);
12410                         ndr->depth++;
12411                         if (r->connectfailures) {
12412                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "connectfailures", r->connectfailures);
12413                         }
12414                         ndr->depth--;
12415                 break;
12416
12417                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12418                         ndr_print_ptr(ndr, "linkfailures", r->linkfailures);
12419                         ndr->depth++;
12420                         if (r->linkfailures) {
12421                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "linkfailures", r->linkfailures);
12422                         }
12423                         ndr->depth--;
12424                 break;
12425
12426                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12427                         ndr_print_ptr(ndr, "pendingops", r->pendingops);
12428                         ndr->depth++;
12429                         if (r->pendingops) {
12430                                 ndr_print_drsuapi_DsReplicaOpCtr(ndr, "pendingops", r->pendingops);
12431                         }
12432                         ndr->depth--;
12433                 break;
12434
12435                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12436                         ndr_print_ptr(ndr, "attrvalmetadata", r->attrvalmetadata);
12437                         ndr->depth++;
12438                         if (r->attrvalmetadata) {
12439                                 ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, "attrvalmetadata", r->attrvalmetadata);
12440                         }
12441                         ndr->depth--;
12442                 break;
12443
12444                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12445                         ndr_print_ptr(ndr, "cursors2", r->cursors2);
12446                         ndr->depth++;
12447                         if (r->cursors2) {
12448                                 ndr_print_drsuapi_DsReplicaCursor2Ctr(ndr, "cursors2", r->cursors2);
12449                         }
12450                         ndr->depth--;
12451                 break;
12452
12453                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12454                         ndr_print_ptr(ndr, "cursors3", r->cursors3);
12455                         ndr->depth++;
12456                         if (r->cursors3) {
12457                                 ndr_print_drsuapi_DsReplicaCursor3Ctr(ndr, "cursors3", r->cursors3);
12458                         }
12459                         ndr->depth--;
12460                 break;
12461
12462                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12463                         ndr_print_ptr(ndr, "objmetadata2", r->objmetadata2);
12464                         ndr->depth++;
12465                         if (r->objmetadata2) {
12466                                 ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(ndr, "objmetadata2", r->objmetadata2);
12467                         }
12468                         ndr->depth--;
12469                 break;
12470
12471                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12472                         ndr_print_ptr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12473                         ndr->depth++;
12474                         if (r->attrvalmetadata2) {
12475                                 ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12476                         }
12477                         ndr->depth--;
12478                 break;
12479
12480                 case DRSUAPI_DS_REPLICA_INFO_REPSTO:
12481                         ndr_print_ptr(ndr, "repsto", r->repsto);
12482                         ndr->depth++;
12483                         if (r->repsto) {
12484                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "repsto", r->repsto);
12485                         }
12486                         ndr->depth--;
12487                 break;
12488
12489                 case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS:
12490                         ndr_print_ptr(ndr, "clientctx", r->clientctx);
12491                         ndr->depth++;
12492                         if (r->clientctx) {
12493                                 ndr_print_drsuapi_DsReplicaConnection04Ctr(ndr, "clientctx", r->clientctx);
12494                         }
12495                         ndr->depth--;
12496                 break;
12497
12498                 case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1:
12499                         ndr_print_ptr(ndr, "udv1", r->udv1);
12500                         ndr->depth++;
12501                         if (r->udv1) {
12502                                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "udv1", r->udv1);
12503                         }
12504                         ndr->depth--;
12505                 break;
12506
12507                 case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS:
12508                         ndr_print_ptr(ndr, "srvoutgoingcalls", r->srvoutgoingcalls);
12509                         ndr->depth++;
12510                         if (r->srvoutgoingcalls) {
12511                                 ndr_print_drsuapi_DsReplica06Ctr(ndr, "srvoutgoingcalls", r->srvoutgoingcalls);
12512                         }
12513                         ndr->depth--;
12514                 break;
12515
12516                 default:
12517                         ndr_print_bad_level(ndr, name, level);
12518         }
12519 }
12520
12521 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Ctr *r)
12522 {
12523         if (ndr_flags & NDR_SCALARS) {
12524                 int level = ndr_push_get_switch_value(ndr, r);
12525                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12526                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12527                 switch (level) {
12528                         case 1: {
12529                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12530                         break; }
12531
12532                         default:
12533                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12534                 }
12535         }
12536         if (ndr_flags & NDR_BUFFERS) {
12537                 int level = ndr_push_get_switch_value(ndr, r);
12538                 switch (level) {
12539                         case 1:
12540                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12541                         break;
12542
12543                         default:
12544                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12545                 }
12546         }
12547         return NDR_ERR_SUCCESS;
12548 }
12549
12550 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Ctr *r)
12551 {
12552         int level;
12553         uint32_t _level;
12554         level = ndr_pull_get_switch_value(ndr, r);
12555         if (ndr_flags & NDR_SCALARS) {
12556                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12557                 if (_level != level) {
12558                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12559                 }
12560                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12561                 switch (level) {
12562                         case 1: {
12563                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12564                         break; }
12565
12566                         default:
12567                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12568                 }
12569         }
12570         if (ndr_flags & NDR_BUFFERS) {
12571                 switch (level) {
12572                         case 1:
12573                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12574                         break;
12575
12576                         default:
12577                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12578                 }
12579         }
12580         return NDR_ERR_SUCCESS;
12581 }
12582
12583 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Ctr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Ctr *r)
12584 {
12585         int level;
12586         level = ndr_print_get_switch_value(ndr, r);
12587         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Ctr");
12588         switch (level) {
12589                 case 1:
12590                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
12591                 break;
12592
12593                 default:
12594                         ndr_print_bad_level(ndr, name, level);
12595         }
12596 }
12597
12598 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMemberships2Request1 *r)
12599 {
12600         uint32_t cntr_req_array_1;
12601         if (ndr_flags & NDR_SCALARS) {
12602                 NDR_CHECK(ndr_push_align(ndr, 5));
12603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
12605                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12606         }
12607         if (ndr_flags & NDR_BUFFERS) {
12608                 if (r->req_array) {
12609                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
12610                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12611                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
12612                         }
12613                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12614                                 if (r->req_array[cntr_req_array_1]) {
12615                                         NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12616                                 }
12617                         }
12618                 }
12619         }
12620         return NDR_ERR_SUCCESS;
12621 }
12622
12623 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
12624 {
12625         uint32_t _ptr_req_array;
12626         uint32_t cntr_req_array_1;
12627         TALLOC_CTX *_mem_save_req_array_0;
12628         TALLOC_CTX *_mem_save_req_array_1;
12629         TALLOC_CTX *_mem_save_req_array_2;
12630         if (ndr_flags & NDR_SCALARS) {
12631                 NDR_CHECK(ndr_pull_align(ndr, 5));
12632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12633                 if (r->num_req < 1 || r->num_req > 10000) {
12634                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12635                 }
12636                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12637                 if (_ptr_req_array) {
12638                         NDR_PULL_ALLOC(ndr, r->req_array);
12639                 } else {
12640                         r->req_array = NULL;
12641                 }
12642                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12643         }
12644         if (ndr_flags & NDR_BUFFERS) {
12645                 if (r->req_array) {
12646                         _mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12647                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12648                         NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
12649                         NDR_PULL_ALLOC_N(ndr, r->req_array, ndr_get_array_size(ndr, &r->req_array));
12650                         _mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12651                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12652                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12653                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12654                                 if (_ptr_req_array) {
12655                                         NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
12656                                 } else {
12657                                         r->req_array[cntr_req_array_1] = NULL;
12658                                 }
12659                         }
12660                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12661                                 if (r->req_array[cntr_req_array_1]) {
12662                                         _mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
12663                                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
12664                                         NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12665                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_2, 0);
12666                                 }
12667                         }
12668                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_1, 0);
12669                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_0, 0);
12670                 }
12671                 if (r->req_array) {
12672                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->req_array, r->num_req));
12673                 }
12674         }
12675         return NDR_ERR_SUCCESS;
12676 }
12677
12678 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMemberships2Request1 *r)
12679 {
12680         uint32_t cntr_req_array_1;
12681         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2Request1");
12682         ndr->depth++;
12683         ndr_print_uint32(ndr, "num_req", r->num_req);
12684         ndr_print_ptr(ndr, "req_array", r->req_array);
12685         ndr->depth++;
12686         if (r->req_array) {
12687                 ndr->print(ndr, "%s: ARRAY(%d)", "req_array", (int)r->num_req);
12688                 ndr->depth++;
12689                 for (cntr_req_array_1=0;cntr_req_array_1<r->num_req;cntr_req_array_1++) {
12690                         char *idx_1=NULL;
12691                         if (asprintf(&idx_1, "[%d]", cntr_req_array_1) != -1) {
12692                                 ndr_print_ptr(ndr, "req_array", r->req_array[cntr_req_array_1]);
12693                                 ndr->depth++;
12694                                 if (r->req_array[cntr_req_array_1]) {
12695                                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req_array", r->req_array[cntr_req_array_1]);
12696                                 }
12697                                 ndr->depth--;
12698                                 free(idx_1);
12699                         }
12700                 }
12701                 ndr->depth--;
12702         }
12703         ndr->depth--;
12704         ndr->depth--;
12705 }
12706
12707 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Request *r)
12708 {
12709         if (ndr_flags & NDR_SCALARS) {
12710                 int level = ndr_push_get_switch_value(ndr, r);
12711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12712                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12713                 switch (level) {
12714                         case 1: {
12715                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12716                         break; }
12717
12718                         default:
12719                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12720                 }
12721         }
12722         if (ndr_flags & NDR_BUFFERS) {
12723                 int level = ndr_push_get_switch_value(ndr, r);
12724                 switch (level) {
12725                         case 1:
12726                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12727                         break;
12728
12729                         default:
12730                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12731                 }
12732         }
12733         return NDR_ERR_SUCCESS;
12734 }
12735
12736 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Request *r)
12737 {
12738         int level;
12739         uint32_t _level;
12740         level = ndr_pull_get_switch_value(ndr, r);
12741         if (ndr_flags & NDR_SCALARS) {
12742                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12743                 if (_level != level) {
12744                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12745                 }
12746                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12747                 switch (level) {
12748                         case 1: {
12749                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12750                         break; }
12751
12752                         default:
12753                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12754                 }
12755         }
12756         if (ndr_flags & NDR_BUFFERS) {
12757                 switch (level) {
12758                         case 1:
12759                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12760                         break;
12761
12762                         default:
12763                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12764                 }
12765         }
12766         return NDR_ERR_SUCCESS;
12767 }
12768
12769 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Request *r)
12770 {
12771         int level;
12772         level = ndr_print_get_switch_value(ndr, r);
12773         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Request");
12774         switch (level) {
12775                 case 1:
12776                         ndr_print_drsuapi_DsGetMemberships2Request1(ndr, "req1", &r->req1);
12777                 break;
12778
12779                 default:
12780                         ndr_print_bad_level(ndr, name, level);
12781         }
12782 }
12783
12784 static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsSiteCostInfo *r)
12785 {
12786         if (ndr_flags & NDR_SCALARS) {
12787                 NDR_CHECK(ndr_push_align(ndr, 4));
12788                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
12789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
12790                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
12791         }
12792         if (ndr_flags & NDR_BUFFERS) {
12793         }
12794         return NDR_ERR_SUCCESS;
12795 }
12796
12797 static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsSiteCostInfo *r)
12798 {
12799         if (ndr_flags & NDR_SCALARS) {
12800                 NDR_CHECK(ndr_pull_align(ndr, 4));
12801                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
12802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
12803                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
12804         }
12805         if (ndr_flags & NDR_BUFFERS) {
12806         }
12807         return NDR_ERR_SUCCESS;
12808 }
12809
12810 _PUBLIC_ void ndr_print_drsuapi_DsSiteCostInfo(struct ndr_print *ndr, const char *name, const struct drsuapi_DsSiteCostInfo *r)
12811 {
12812         ndr_print_struct(ndr, name, "drsuapi_DsSiteCostInfo");
12813         ndr->depth++;
12814         ndr_print_WERROR(ndr, "error_code", r->error_code);
12815         ndr_print_uint32(ndr, "site_cost", r->site_cost);
12816         ndr->depth--;
12817 }
12818
12819 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostCtr1 *r)
12820 {
12821         uint32_t cntr_info_1;
12822         if (ndr_flags & NDR_SCALARS) {
12823                 NDR_CHECK(ndr_push_align(ndr, 5));
12824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
12825                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
12826                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12827                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12828         }
12829         if (ndr_flags & NDR_BUFFERS) {
12830                 if (r->info) {
12831                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_info));
12832                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12833                                 NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12834                         }
12835                 }
12836         }
12837         return NDR_ERR_SUCCESS;
12838 }
12839
12840 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
12841 {
12842         uint32_t _ptr_info;
12843         uint32_t cntr_info_1;
12844         TALLOC_CTX *_mem_save_info_0;
12845         TALLOC_CTX *_mem_save_info_1;
12846         if (ndr_flags & NDR_SCALARS) {
12847                 NDR_CHECK(ndr_pull_align(ndr, 5));
12848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
12849                 if (r->num_info > 10000) {
12850                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12851                 }
12852                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12853                 if (_ptr_info) {
12854                         NDR_PULL_ALLOC(ndr, r->info);
12855                 } else {
12856                         r->info = NULL;
12857                 }
12858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags_reserved));
12859                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12860         }
12861         if (ndr_flags & NDR_BUFFERS) {
12862                 if (r->info) {
12863                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12864                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12865                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
12866                         NDR_PULL_ALLOC_N(ndr, r->info, ndr_get_array_size(ndr, &r->info));
12867                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
12868                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12869                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12870                                 NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12871                         }
12872                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
12873                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12874                 }
12875                 if (r->info) {
12876                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info, r->num_info));
12877                 }
12878         }
12879         return NDR_ERR_SUCCESS;
12880 }
12881
12882 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostCtr1 *r)
12883 {
12884         uint32_t cntr_info_1;
12885         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostCtr1");
12886         ndr->depth++;
12887         ndr_print_uint32(ndr, "num_info", r->num_info);
12888         ndr_print_ptr(ndr, "info", r->info);
12889         ndr->depth++;
12890         if (r->info) {
12891                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->num_info);
12892                 ndr->depth++;
12893                 for (cntr_info_1=0;cntr_info_1<r->num_info;cntr_info_1++) {
12894                         char *idx_1=NULL;
12895                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12896                                 ndr_print_drsuapi_DsSiteCostInfo(ndr, "info", &r->info[cntr_info_1]);
12897                                 free(idx_1);
12898                         }
12899                 }
12900                 ndr->depth--;
12901         }
12902         ndr->depth--;
12903         ndr_print_uint32(ndr, "flags_reserved", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->flags_reserved);
12904         ndr->depth--;
12905 }
12906
12907 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostCtr *r)
12908 {
12909         if (ndr_flags & NDR_SCALARS) {
12910                 int level = ndr_push_get_switch_value(ndr, r);
12911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12912                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12913                 switch (level) {
12914                         case 1: {
12915                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12916                         break; }
12917
12918                         default:
12919                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12920                 }
12921         }
12922         if (ndr_flags & NDR_BUFFERS) {
12923                 int level = ndr_push_get_switch_value(ndr, r);
12924                 switch (level) {
12925                         case 1:
12926                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12927                         break;
12928
12929                         default:
12930                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12931                 }
12932         }
12933         return NDR_ERR_SUCCESS;
12934 }
12935
12936 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostCtr *r)
12937 {
12938         int level;
12939         uint32_t _level;
12940         level = ndr_pull_get_switch_value(ndr, r);
12941         if (ndr_flags & NDR_SCALARS) {
12942                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12943                 if (_level != level) {
12944                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12945                 }
12946                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12947                 switch (level) {
12948                         case 1: {
12949                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12950                         break; }
12951
12952                         default:
12953                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12954                 }
12955         }
12956         if (ndr_flags & NDR_BUFFERS) {
12957                 switch (level) {
12958                         case 1:
12959                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12960                         break;
12961
12962                         default:
12963                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12964                 }
12965         }
12966         return NDR_ERR_SUCCESS;
12967 }
12968
12969 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostCtr *r)
12970 {
12971         int level;
12972         level = ndr_print_get_switch_value(ndr, r);
12973         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostCtr");
12974         switch (level) {
12975                 case 1:
12976                         ndr_print_drsuapi_QuerySitesByCostCtr1(ndr, "ctr1", &r->ctr1);
12977                 break;
12978
12979                 default:
12980                         ndr_print_bad_level(ndr, name, level);
12981         }
12982 }
12983
12984 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostRequest1 *r)
12985 {
12986         uint32_t cntr_site_to_1;
12987         if (ndr_flags & NDR_SCALARS) {
12988                 NDR_CHECK(ndr_push_align(ndr, 5));
12989                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
12990                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12991                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
12992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
12993                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12994         }
12995         if (ndr_flags & NDR_BUFFERS) {
12996                 if (r->site_from) {
12997                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
12998                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
12999                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13000                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13001                 }
13002                 if (r->site_to) {
13003                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
13004                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13005                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
13006                         }
13007                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13008                                 if (r->site_to[cntr_site_to_1]) {
13009                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13010                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13011                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13012                                         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));
13013                                 }
13014                         }
13015                 }
13016         }
13017         return NDR_ERR_SUCCESS;
13018 }
13019
13020 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
13021 {
13022         uint32_t _ptr_site_from;
13023         TALLOC_CTX *_mem_save_site_from_0;
13024         uint32_t _ptr_site_to;
13025         uint32_t cntr_site_to_1;
13026         TALLOC_CTX *_mem_save_site_to_0;
13027         TALLOC_CTX *_mem_save_site_to_1;
13028         TALLOC_CTX *_mem_save_site_to_2;
13029         if (ndr_flags & NDR_SCALARS) {
13030                 NDR_CHECK(ndr_pull_align(ndr, 5));
13031                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
13032                 if (_ptr_site_from) {
13033                         NDR_PULL_ALLOC(ndr, r->site_from);
13034                 } else {
13035                         r->site_from = NULL;
13036                 }
13037                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
13038                 if (r->num_req < 1 || r->num_req > 10000) {
13039                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
13040                 }
13041                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13042                 if (_ptr_site_to) {
13043                         NDR_PULL_ALLOC(ndr, r->site_to);
13044                 } else {
13045                         r->site_to = NULL;
13046                 }
13047                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13048                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13049         }
13050         if (ndr_flags & NDR_BUFFERS) {
13051                 if (r->site_from) {
13052                         _mem_save_site_from_0 = NDR_PULL_GET_MEM_CTX(ndr);
13053                         NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
13054                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
13055                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
13056                         if (ndr_get_array_length(ndr, &r->site_from) > ndr_get_array_size(ndr, &r->site_from)) {
13057                                 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));
13058                         }
13059                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t)));
13060                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t), CH_UTF16));
13061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
13062                 }
13063                 if (r->site_to) {
13064                         _mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
13065                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13066                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
13067                         NDR_PULL_ALLOC_N(ndr, r->site_to, ndr_get_array_size(ndr, &r->site_to));
13068                         _mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
13069                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13070                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13071                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13072                                 if (_ptr_site_to) {
13073                                         NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
13074                                 } else {
13075                                         r->site_to[cntr_site_to_1] = NULL;
13076                                 }
13077                         }
13078                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13079                                 if (r->site_to[cntr_site_to_1]) {
13080                                         _mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
13081                                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
13082                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
13083                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
13084                                         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])) {
13085                                                 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]));
13086                                         }
13087                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t)));
13088                                         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));
13089                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
13090                                 }
13091                         }
13092                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_1, 0);
13093                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_0, 0);
13094                 }
13095                 if (r->site_to) {
13096                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->site_to, r->num_req));
13097                 }
13098         }
13099         return NDR_ERR_SUCCESS;
13100 }
13101
13102 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostRequest1 *r)
13103 {
13104         uint32_t cntr_site_to_1;
13105         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostRequest1");
13106         ndr->depth++;
13107         ndr_print_ptr(ndr, "site_from", r->site_from);
13108         ndr->depth++;
13109         if (r->site_from) {
13110                 ndr_print_string(ndr, "site_from", r->site_from);
13111         }
13112         ndr->depth--;
13113         ndr_print_uint32(ndr, "num_req", r->num_req);
13114         ndr_print_ptr(ndr, "site_to", r->site_to);
13115         ndr->depth++;
13116         if (r->site_to) {
13117                 ndr->print(ndr, "%s: ARRAY(%d)", "site_to", (int)r->num_req);
13118                 ndr->depth++;
13119                 for (cntr_site_to_1=0;cntr_site_to_1<r->num_req;cntr_site_to_1++) {
13120                         char *idx_1=NULL;
13121                         if (asprintf(&idx_1, "[%d]", cntr_site_to_1) != -1) {
13122                                 ndr_print_ptr(ndr, "site_to", r->site_to[cntr_site_to_1]);
13123                                 ndr->depth++;
13124                                 if (r->site_to[cntr_site_to_1]) {
13125                                         ndr_print_string(ndr, "site_to", r->site_to[cntr_site_to_1]);
13126                                 }
13127                                 ndr->depth--;
13128                                 free(idx_1);
13129                         }
13130                 }
13131                 ndr->depth--;
13132         }
13133         ndr->depth--;
13134         ndr_print_uint32(ndr, "flags", r->flags);
13135         ndr->depth--;
13136 }
13137
13138 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostRequest *r)
13139 {
13140         if (ndr_flags & NDR_SCALARS) {
13141                 int level = ndr_push_get_switch_value(ndr, r);
13142                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
13143                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13144                 switch (level) {
13145                         case 1: {
13146                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13147                         break; }
13148
13149                         default:
13150                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13151                 }
13152         }
13153         if (ndr_flags & NDR_BUFFERS) {
13154                 int level = ndr_push_get_switch_value(ndr, r);
13155                 switch (level) {
13156                         case 1:
13157                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13158                         break;
13159
13160                         default:
13161                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13162                 }
13163         }
13164         return NDR_ERR_SUCCESS;
13165 }
13166
13167 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostRequest *r)
13168 {
13169         int level;
13170         uint32_t _level;
13171         level = ndr_pull_get_switch_value(ndr, r);
13172         if (ndr_flags & NDR_SCALARS) {
13173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
13174                 if (_level != level) {
13175                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13176                 }
13177                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13178                 switch (level) {
13179                         case 1: {
13180                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13181                         break; }
13182
13183                         default:
13184                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13185                 }
13186         }
13187         if (ndr_flags & NDR_BUFFERS) {
13188                 switch (level) {
13189                         case 1:
13190                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13191                         break;
13192
13193                         default:
13194                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13195                 }
13196         }
13197         return NDR_ERR_SUCCESS;
13198 }
13199
13200 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostRequest *r)
13201 {
13202         int level;
13203         level = ndr_print_get_switch_value(ndr, r);
13204         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostRequest");
13205         switch (level) {
13206                 case 1:
13207                         ndr_print_drsuapi_QuerySitesByCostRequest1(ndr, "req1", &r->req1);
13208                 break;
13209
13210                 default:
13211                         ndr_print_bad_level(ndr, name, level);
13212         }
13213 }
13214
13215 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsBind(struct ndr_push *ndr, int flags, const struct drsuapi_DsBind *r)
13216 {
13217         if (flags & NDR_IN) {
13218                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_guid));
13219                 if (r->in.bind_guid) {
13220                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13221                 }
13222                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_info));
13223                 if (r->in.bind_info) {
13224                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13225                 }
13226         }
13227         if (flags & NDR_OUT) {
13228                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.bind_info));
13229                 if (r->out.bind_info) {
13230                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13231                 }
13232                 if (r->out.bind_handle == NULL) {
13233                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13234                 }
13235                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13236                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13237         }
13238         return NDR_ERR_SUCCESS;
13239 }
13240
13241 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsBind(struct ndr_pull *ndr, int flags, struct drsuapi_DsBind *r)
13242 {
13243         uint32_t _ptr_bind_guid;
13244         uint32_t _ptr_bind_info;
13245         TALLOC_CTX *_mem_save_bind_guid_0;
13246         TALLOC_CTX *_mem_save_bind_info_0;
13247         TALLOC_CTX *_mem_save_bind_handle_0;
13248         if (flags & NDR_IN) {
13249                 ZERO_STRUCT(r->out);
13250
13251                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_guid));
13252                 if (_ptr_bind_guid) {
13253                         NDR_PULL_ALLOC(ndr, r->in.bind_guid);
13254                 } else {
13255                         r->in.bind_guid = NULL;
13256                 }
13257                 if (r->in.bind_guid) {
13258                         _mem_save_bind_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
13259                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_guid, 0);
13260                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13261                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_guid_0, 0);
13262                 }
13263                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13264                 if (_ptr_bind_info) {
13265                         NDR_PULL_ALLOC(ndr, r->in.bind_info);
13266                 } else {
13267                         r->in.bind_info = NULL;
13268                 }
13269                 if (r->in.bind_info) {
13270                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13271                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_info, 0);
13272                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13273                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13274                 }
13275                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13276                 ZERO_STRUCTP(r->out.bind_handle);
13277         }
13278         if (flags & NDR_OUT) {
13279                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13280                 if (_ptr_bind_info) {
13281                         NDR_PULL_ALLOC(ndr, r->out.bind_info);
13282                 } else {
13283                         r->out.bind_info = NULL;
13284                 }
13285                 if (r->out.bind_info) {
13286                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13287                         NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_info, 0);
13288                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13289                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13290                 }
13291                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13292                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13293                 }
13294                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13295                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13296                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13297                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13298                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13299         }
13300         return NDR_ERR_SUCCESS;
13301 }
13302
13303 _PUBLIC_ void ndr_print_drsuapi_DsBind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsBind *r)
13304 {
13305         ndr_print_struct(ndr, name, "drsuapi_DsBind");
13306         ndr->depth++;
13307         if (flags & NDR_SET_VALUES) {
13308                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13309         }
13310         if (flags & NDR_IN) {
13311                 ndr_print_struct(ndr, "in", "drsuapi_DsBind");
13312                 ndr->depth++;
13313                 ndr_print_ptr(ndr, "bind_guid", r->in.bind_guid);
13314                 ndr->depth++;
13315                 if (r->in.bind_guid) {
13316                         ndr_print_GUID(ndr, "bind_guid", r->in.bind_guid);
13317                 }
13318                 ndr->depth--;
13319                 ndr_print_ptr(ndr, "bind_info", r->in.bind_info);
13320                 ndr->depth++;
13321                 if (r->in.bind_info) {
13322                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->in.bind_info);
13323                 }
13324                 ndr->depth--;
13325                 ndr->depth--;
13326         }
13327         if (flags & NDR_OUT) {
13328                 ndr_print_struct(ndr, "out", "drsuapi_DsBind");
13329                 ndr->depth++;
13330                 ndr_print_ptr(ndr, "bind_info", r->out.bind_info);
13331                 ndr->depth++;
13332                 if (r->out.bind_info) {
13333                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->out.bind_info);
13334                 }
13335                 ndr->depth--;
13336                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13337                 ndr->depth++;
13338                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13339                 ndr->depth--;
13340                 ndr_print_WERROR(ndr, "result", r->out.result);
13341                 ndr->depth--;
13342         }
13343         ndr->depth--;
13344 }
13345
13346 static enum ndr_err_code ndr_push_drsuapi_DsUnbind(struct ndr_push *ndr, int flags, const struct drsuapi_DsUnbind *r)
13347 {
13348         if (flags & NDR_IN) {
13349                 if (r->in.bind_handle == NULL) {
13350                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13351                 }
13352                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13353         }
13354         if (flags & NDR_OUT) {
13355                 if (r->out.bind_handle == NULL) {
13356                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13357                 }
13358                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13359                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13360         }
13361         return NDR_ERR_SUCCESS;
13362 }
13363
13364 static enum ndr_err_code ndr_pull_drsuapi_DsUnbind(struct ndr_pull *ndr, int flags, struct drsuapi_DsUnbind *r)
13365 {
13366         TALLOC_CTX *_mem_save_bind_handle_0;
13367         if (flags & NDR_IN) {
13368                 ZERO_STRUCT(r->out);
13369
13370                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13371                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13372                 }
13373                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13374                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13375                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13376                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13377                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13378                 *r->out.bind_handle = *r->in.bind_handle;
13379         }
13380         if (flags & NDR_OUT) {
13381                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13382                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13383                 }
13384                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13385                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13386                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13387                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13388                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13389         }
13390         return NDR_ERR_SUCCESS;
13391 }
13392
13393 _PUBLIC_ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsUnbind *r)
13394 {
13395         ndr_print_struct(ndr, name, "drsuapi_DsUnbind");
13396         ndr->depth++;
13397         if (flags & NDR_SET_VALUES) {
13398                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13399         }
13400         if (flags & NDR_IN) {
13401                 ndr_print_struct(ndr, "in", "drsuapi_DsUnbind");
13402                 ndr->depth++;
13403                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13404                 ndr->depth++;
13405                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13406                 ndr->depth--;
13407                 ndr->depth--;
13408         }
13409         if (flags & NDR_OUT) {
13410                 ndr_print_struct(ndr, "out", "drsuapi_DsUnbind");
13411                 ndr->depth++;
13412                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13413                 ndr->depth++;
13414                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13415                 ndr->depth--;
13416                 ndr_print_WERROR(ndr, "result", r->out.result);
13417                 ndr->depth--;
13418         }
13419         ndr->depth--;
13420 }
13421
13422 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSync(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaSync *r)
13423 {
13424         if (flags & NDR_IN) {
13425                 if (r->in.bind_handle == NULL) {
13426                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13427                 }
13428                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13430                 if (r->in.req == NULL) {
13431                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13432                 }
13433                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13434                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13435         }
13436         if (flags & NDR_OUT) {
13437                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13438         }
13439         return NDR_ERR_SUCCESS;
13440 }
13441
13442 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSync(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaSync *r)
13443 {
13444         TALLOC_CTX *_mem_save_bind_handle_0;
13445         TALLOC_CTX *_mem_save_req_0;
13446         if (flags & NDR_IN) {
13447                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13448                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13449                 }
13450                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13451                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13452                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13453                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13454                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13455                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13456                         NDR_PULL_ALLOC(ndr, r->in.req);
13457                 }
13458                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13459                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13460                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13461                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13462                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13463         }
13464         if (flags & NDR_OUT) {
13465                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13466         }
13467         return NDR_ERR_SUCCESS;
13468 }
13469
13470 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r)
13471 {
13472         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSync");
13473         ndr->depth++;
13474         if (flags & NDR_SET_VALUES) {
13475                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13476         }
13477         if (flags & NDR_IN) {
13478                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaSync");
13479                 ndr->depth++;
13480                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13481                 ndr->depth++;
13482                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13483                 ndr->depth--;
13484                 ndr_print_uint32(ndr, "level", r->in.level);
13485                 ndr_print_ptr(ndr, "req", r->in.req);
13486                 ndr->depth++;
13487                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13488                 ndr_print_drsuapi_DsReplicaSyncRequest(ndr, "req", r->in.req);
13489                 ndr->depth--;
13490                 ndr->depth--;
13491         }
13492         if (flags & NDR_OUT) {
13493                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaSync");
13494                 ndr->depth++;
13495                 ndr_print_WERROR(ndr, "result", r->out.result);
13496                 ndr->depth--;
13497         }
13498         ndr->depth--;
13499 }
13500
13501 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChanges(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNCChanges *r)
13502 {
13503         if (flags & NDR_IN) {
13504                 if (r->in.bind_handle == NULL) {
13505                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13506                 }
13507                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13508                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13509                 if (r->in.req == NULL) {
13510                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13511                 }
13512                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13513                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13514         }
13515         if (flags & NDR_OUT) {
13516                 if (r->out.level_out == NULL) {
13517                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13518                 }
13519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
13520                 if (r->out.ctr == NULL) {
13521                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13522                 }
13523                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13524                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13525                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13526         }
13527         return NDR_ERR_SUCCESS;
13528 }
13529
13530 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChanges(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNCChanges *r)
13531 {
13532         TALLOC_CTX *_mem_save_bind_handle_0;
13533         TALLOC_CTX *_mem_save_req_0;
13534         TALLOC_CTX *_mem_save_level_out_0;
13535         TALLOC_CTX *_mem_save_ctr_0;
13536         if (flags & NDR_IN) {
13537                 ZERO_STRUCT(r->out);
13538
13539                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13540                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13541                 }
13542                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13543                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13544                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13545                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13547                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13548                         NDR_PULL_ALLOC(ndr, r->in.req);
13549                 }
13550                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13551                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13552                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13553                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13554                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13555                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13556                 ZERO_STRUCTP(r->out.level_out);
13557                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13558                 ZERO_STRUCTP(r->out.ctr);
13559         }
13560         if (flags & NDR_OUT) {
13561                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13562                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13563                 }
13564                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13565                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
13567                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13568                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13569                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13570                 }
13571                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13572                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13573                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13574                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13575                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13576                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13577         }
13578         return NDR_ERR_SUCCESS;
13579 }
13580
13581 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r)
13582 {
13583         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChanges");
13584         ndr->depth++;
13585         if (flags & NDR_SET_VALUES) {
13586                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13587         }
13588         if (flags & NDR_IN) {
13589                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNCChanges");
13590                 ndr->depth++;
13591                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13592                 ndr->depth++;
13593                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13594                 ndr->depth--;
13595                 ndr_print_uint32(ndr, "level", r->in.level);
13596                 ndr_print_ptr(ndr, "req", r->in.req);
13597                 ndr->depth++;
13598                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13599                 ndr_print_drsuapi_DsGetNCChangesRequest(ndr, "req", r->in.req);
13600                 ndr->depth--;
13601                 ndr->depth--;
13602         }
13603         if (flags & NDR_OUT) {
13604                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNCChanges");
13605                 ndr->depth++;
13606                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13607                 ndr->depth++;
13608                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
13609                 ndr->depth--;
13610                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13611                 ndr->depth++;
13612                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13613                 ndr_print_drsuapi_DsGetNCChangesCtr(ndr, "ctr", r->out.ctr);
13614                 ndr->depth--;
13615                 ndr_print_WERROR(ndr, "result", r->out.result);
13616                 ndr->depth--;
13617         }
13618         ndr->depth--;
13619 }
13620
13621 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefs(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13622 {
13623         if (flags & NDR_IN) {
13624                 if (r->in.bind_handle == NULL) {
13625                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13626                 }
13627                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13629                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13630                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13631         }
13632         if (flags & NDR_OUT) {
13633                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13634         }
13635         return NDR_ERR_SUCCESS;
13636 }
13637
13638 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefs(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaUpdateRefs *r)
13639 {
13640         TALLOC_CTX *_mem_save_bind_handle_0;
13641         if (flags & NDR_IN) {
13642                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13643                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13644                 }
13645                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13646                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13647                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13648                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13650                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13651                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13652         }
13653         if (flags & NDR_OUT) {
13654                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13655         }
13656         return NDR_ERR_SUCCESS;
13657 }
13658
13659 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13660 {
13661         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefs");
13662         ndr->depth++;
13663         if (flags & NDR_SET_VALUES) {
13664                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13665         }
13666         if (flags & NDR_IN) {
13667                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaUpdateRefs");
13668                 ndr->depth++;
13669                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13670                 ndr->depth++;
13671                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13672                 ndr->depth--;
13673                 ndr_print_uint32(ndr, "level", r->in.level);
13674                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13675                 ndr_print_drsuapi_DsReplicaUpdateRefsRequest(ndr, "req", &r->in.req);
13676                 ndr->depth--;
13677         }
13678         if (flags & NDR_OUT) {
13679                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaUpdateRefs");
13680                 ndr->depth++;
13681                 ndr_print_WERROR(ndr, "result", r->out.result);
13682                 ndr->depth--;
13683         }
13684         ndr->depth--;
13685 }
13686
13687 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAdd(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaAdd *r)
13688 {
13689         if (flags & NDR_IN) {
13690                 if (r->in.bind_handle == NULL) {
13691                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13692                 }
13693                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13695                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13696                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13697         }
13698         if (flags & NDR_OUT) {
13699                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13700         }
13701         return NDR_ERR_SUCCESS;
13702 }
13703
13704 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAdd(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaAdd *r)
13705 {
13706         TALLOC_CTX *_mem_save_bind_handle_0;
13707         if (flags & NDR_IN) {
13708                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13709                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13710                 }
13711                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13712                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13713                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13714                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13716                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13717                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13718         }
13719         if (flags & NDR_OUT) {
13720                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13721         }
13722         return NDR_ERR_SUCCESS;
13723 }
13724
13725 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r)
13726 {
13727         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAdd");
13728         ndr->depth++;
13729         if (flags & NDR_SET_VALUES) {
13730                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13731         }
13732         if (flags & NDR_IN) {
13733                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaAdd");
13734                 ndr->depth++;
13735                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13736                 ndr->depth++;
13737                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13738                 ndr->depth--;
13739                 ndr_print_uint32(ndr, "level", r->in.level);
13740                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13741                 ndr_print_drsuapi_DsReplicaAddRequest(ndr, "req", &r->in.req);
13742                 ndr->depth--;
13743         }
13744         if (flags & NDR_OUT) {
13745                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaAdd");
13746                 ndr->depth++;
13747                 ndr_print_WERROR(ndr, "result", r->out.result);
13748                 ndr->depth--;
13749         }
13750         ndr->depth--;
13751 }
13752
13753 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDel(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaDel *r)
13754 {
13755         if (flags & NDR_IN) {
13756                 if (r->in.bind_handle == NULL) {
13757                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13758                 }
13759                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13761                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13762                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13763         }
13764         if (flags & NDR_OUT) {
13765                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13766         }
13767         return NDR_ERR_SUCCESS;
13768 }
13769
13770 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDel(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaDel *r)
13771 {
13772         TALLOC_CTX *_mem_save_bind_handle_0;
13773         if (flags & NDR_IN) {
13774                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13775                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13776                 }
13777                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13778                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13779                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13780                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13782                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13783                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13784         }
13785         if (flags & NDR_OUT) {
13786                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13787         }
13788         return NDR_ERR_SUCCESS;
13789 }
13790
13791 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r)
13792 {
13793         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDel");
13794         ndr->depth++;
13795         if (flags & NDR_SET_VALUES) {
13796                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13797         }
13798         if (flags & NDR_IN) {
13799                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaDel");
13800                 ndr->depth++;
13801                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13802                 ndr->depth++;
13803                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13804                 ndr->depth--;
13805                 ndr_print_uint32(ndr, "level", r->in.level);
13806                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13807                 ndr_print_drsuapi_DsReplicaDelRequest(ndr, "req", &r->in.req);
13808                 ndr->depth--;
13809         }
13810         if (flags & NDR_OUT) {
13811                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaDel");
13812                 ndr->depth++;
13813                 ndr_print_WERROR(ndr, "result", r->out.result);
13814                 ndr->depth--;
13815         }
13816         ndr->depth--;
13817 }
13818
13819 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMod(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaMod *r)
13820 {
13821         if (flags & NDR_IN) {
13822                 if (r->in.bind_handle == NULL) {
13823                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13824                 }
13825                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13826                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13827                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13828                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13829         }
13830         if (flags & NDR_OUT) {
13831                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13832         }
13833         return NDR_ERR_SUCCESS;
13834 }
13835
13836 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMod(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaMod *r)
13837 {
13838         TALLOC_CTX *_mem_save_bind_handle_0;
13839         if (flags & NDR_IN) {
13840                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13841                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13842                 }
13843                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13844                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13845                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13846                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13848                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13849                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13850         }
13851         if (flags & NDR_OUT) {
13852                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13853         }
13854         return NDR_ERR_SUCCESS;
13855 }
13856
13857 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r)
13858 {
13859         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMod");
13860         ndr->depth++;
13861         if (flags & NDR_SET_VALUES) {
13862                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13863         }
13864         if (flags & NDR_IN) {
13865                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaMod");
13866                 ndr->depth++;
13867                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13868                 ndr->depth++;
13869                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13870                 ndr->depth--;
13871                 ndr_print_uint32(ndr, "level", r->in.level);
13872                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13873                 ndr_print_drsuapi_DsReplicaModRequest(ndr, "req", &r->in.req);
13874                 ndr->depth--;
13875         }
13876         if (flags & NDR_OUT) {
13877                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaMod");
13878                 ndr->depth++;
13879                 ndr_print_WERROR(ndr, "result", r->out.result);
13880                 ndr->depth--;
13881         }
13882         ndr->depth--;
13883 }
13884
13885 static enum ndr_err_code ndr_push_DRSUAPI_VERIFY_NAMES(struct ndr_push *ndr, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13886 {
13887         if (flags & NDR_IN) {
13888         }
13889         if (flags & NDR_OUT) {
13890                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13891         }
13892         return NDR_ERR_SUCCESS;
13893 }
13894
13895 static enum ndr_err_code ndr_pull_DRSUAPI_VERIFY_NAMES(struct ndr_pull *ndr, int flags, struct DRSUAPI_VERIFY_NAMES *r)
13896 {
13897         if (flags & NDR_IN) {
13898         }
13899         if (flags & NDR_OUT) {
13900                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13901         }
13902         return NDR_ERR_SUCCESS;
13903 }
13904
13905 _PUBLIC_ void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13906 {
13907         ndr_print_struct(ndr, name, "DRSUAPI_VERIFY_NAMES");
13908         ndr->depth++;
13909         if (flags & NDR_SET_VALUES) {
13910                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13911         }
13912         if (flags & NDR_IN) {
13913                 ndr_print_struct(ndr, "in", "DRSUAPI_VERIFY_NAMES");
13914                 ndr->depth++;
13915                 ndr->depth--;
13916         }
13917         if (flags & NDR_OUT) {
13918                 ndr_print_struct(ndr, "out", "DRSUAPI_VERIFY_NAMES");
13919                 ndr->depth++;
13920                 ndr_print_WERROR(ndr, "result", r->out.result);
13921                 ndr->depth--;
13922         }
13923         ndr->depth--;
13924 }
13925
13926 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships *r)
13927 {
13928         if (flags & NDR_IN) {
13929                 if (r->in.bind_handle == NULL) {
13930                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13931                 }
13932                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13934                 if (r->in.req == NULL) {
13935                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13936                 }
13937                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13938                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13939         }
13940         if (flags & NDR_OUT) {
13941                 if (r->out.level_out == NULL) {
13942                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13943                 }
13944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
13945                 if (r->out.ctr == NULL) {
13946                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13947                 }
13948                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13949                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13950                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13951         }
13952         return NDR_ERR_SUCCESS;
13953 }
13954
13955 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships *r)
13956 {
13957         TALLOC_CTX *_mem_save_bind_handle_0;
13958         TALLOC_CTX *_mem_save_req_0;
13959         TALLOC_CTX *_mem_save_level_out_0;
13960         TALLOC_CTX *_mem_save_ctr_0;
13961         if (flags & NDR_IN) {
13962                 ZERO_STRUCT(r->out);
13963
13964                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13965                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13966                 }
13967                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13968                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13969                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13970                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13972                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13973                         NDR_PULL_ALLOC(ndr, r->in.req);
13974                 }
13975                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13976                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13977                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13978                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13979                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13980                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13981                 ZERO_STRUCTP(r->out.level_out);
13982                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13983                 ZERO_STRUCTP(r->out.ctr);
13984         }
13985         if (flags & NDR_OUT) {
13986                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13987                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13988                 }
13989                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13990                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
13992                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13993                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13994                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13995                 }
13996                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13997                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13998                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13999                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14000                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14001                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14002         }
14003         return NDR_ERR_SUCCESS;
14004 }
14005
14006 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r)
14007 {
14008         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships");
14009         ndr->depth++;
14010         if (flags & NDR_SET_VALUES) {
14011                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14012         }
14013         if (flags & NDR_IN) {
14014                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships");
14015                 ndr->depth++;
14016                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14017                 ndr->depth++;
14018                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14019                 ndr->depth--;
14020                 ndr_print_uint32(ndr, "level", r->in.level);
14021                 ndr_print_ptr(ndr, "req", r->in.req);
14022                 ndr->depth++;
14023                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14024                 ndr_print_drsuapi_DsGetMembershipsRequest(ndr, "req", r->in.req);
14025                 ndr->depth--;
14026                 ndr->depth--;
14027         }
14028         if (flags & NDR_OUT) {
14029                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships");
14030                 ndr->depth++;
14031                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14032                 ndr->depth++;
14033                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14034                 ndr->depth--;
14035                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14036                 ndr->depth++;
14037                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14038                 ndr_print_drsuapi_DsGetMembershipsCtr(ndr, "ctr", r->out.ctr);
14039                 ndr->depth--;
14040                 ndr_print_WERROR(ndr, "result", r->out.result);
14041                 ndr->depth--;
14042         }
14043         ndr->depth--;
14044 }
14045
14046 static enum ndr_err_code ndr_push_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_push *ndr, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14047 {
14048         if (flags & NDR_IN) {
14049         }
14050         if (flags & NDR_OUT) {
14051                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14052         }
14053         return NDR_ERR_SUCCESS;
14054 }
14055
14056 static enum ndr_err_code ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_pull *ndr, int flags, struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14057 {
14058         if (flags & NDR_IN) {
14059         }
14060         if (flags & NDR_OUT) {
14061                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14062         }
14063         return NDR_ERR_SUCCESS;
14064 }
14065
14066 _PUBLIC_ void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14067 {
14068         ndr_print_struct(ndr, name, "DRSUAPI_INTER_DOMAIN_MOVE");
14069         ndr->depth++;
14070         if (flags & NDR_SET_VALUES) {
14071                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14072         }
14073         if (flags & NDR_IN) {
14074                 ndr_print_struct(ndr, "in", "DRSUAPI_INTER_DOMAIN_MOVE");
14075                 ndr->depth++;
14076                 ndr->depth--;
14077         }
14078         if (flags & NDR_OUT) {
14079                 ndr_print_struct(ndr, "out", "DRSUAPI_INTER_DOMAIN_MOVE");
14080                 ndr->depth++;
14081                 ndr_print_WERROR(ndr, "result", r->out.result);
14082                 ndr->depth--;
14083         }
14084         ndr->depth--;
14085 }
14086
14087 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLog(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14088 {
14089         if (flags & NDR_IN) {
14090                 if (r->in.bind_handle == NULL) {
14091                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14092                 }
14093                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14095                 if (r->in.req == NULL) {
14096                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14097                 }
14098                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14099                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14100         }
14101         if (flags & NDR_OUT) {
14102                 if (r->out.level_out == NULL) {
14103                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14104                 }
14105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14106                 if (r->out.info == NULL) {
14107                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14108                 }
14109                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.level_out));
14110                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14111                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14112         }
14113         return NDR_ERR_SUCCESS;
14114 }
14115
14116 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLog(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNT4ChangeLog *r)
14117 {
14118         TALLOC_CTX *_mem_save_bind_handle_0;
14119         TALLOC_CTX *_mem_save_req_0;
14120         TALLOC_CTX *_mem_save_level_out_0;
14121         TALLOC_CTX *_mem_save_info_0;
14122         if (flags & NDR_IN) {
14123                 ZERO_STRUCT(r->out);
14124
14125                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14126                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14127                 }
14128                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14129                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14130                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14131                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14133                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14134                         NDR_PULL_ALLOC(ndr, r->in.req);
14135                 }
14136                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14137                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14138                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14139                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14140                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14141                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14142                 ZERO_STRUCTP(r->out.level_out);
14143                 NDR_PULL_ALLOC(ndr, r->out.info);
14144                 ZERO_STRUCTP(r->out.info);
14145         }
14146         if (flags & NDR_OUT) {
14147                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14148                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14149                 }
14150                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14151                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14153                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14154                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14155                         NDR_PULL_ALLOC(ndr, r->out.info);
14156                 }
14157                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14158                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14159                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.level_out));
14160                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14161                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14162                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14163         }
14164         return NDR_ERR_SUCCESS;
14165 }
14166
14167 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLog(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14168 {
14169         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLog");
14170         ndr->depth++;
14171         if (flags & NDR_SET_VALUES) {
14172                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14173         }
14174         if (flags & NDR_IN) {
14175                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNT4ChangeLog");
14176                 ndr->depth++;
14177                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14178                 ndr->depth++;
14179                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14180                 ndr->depth--;
14181                 ndr_print_uint32(ndr, "level", r->in.level);
14182                 ndr_print_ptr(ndr, "req", r->in.req);
14183                 ndr->depth++;
14184                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14185                 ndr_print_drsuapi_DsGetNT4ChangeLogRequest(ndr, "req", r->in.req);
14186                 ndr->depth--;
14187                 ndr->depth--;
14188         }
14189         if (flags & NDR_OUT) {
14190                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNT4ChangeLog");
14191                 ndr->depth++;
14192                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14193                 ndr->depth++;
14194                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14195                 ndr->depth--;
14196                 ndr_print_ptr(ndr, "info", r->out.info);
14197                 ndr->depth++;
14198                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.level_out);
14199                 ndr_print_drsuapi_DsGetNT4ChangeLogInfo(ndr, "info", r->out.info);
14200                 ndr->depth--;
14201                 ndr_print_WERROR(ndr, "result", r->out.result);
14202                 ndr->depth--;
14203         }
14204         ndr->depth--;
14205 }
14206
14207 static enum ndr_err_code ndr_push_drsuapi_DsCrackNames(struct ndr_push *ndr, int flags, const struct drsuapi_DsCrackNames *r)
14208 {
14209         if (flags & NDR_IN) {
14210                 if (r->in.bind_handle == NULL) {
14211                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14212                 }
14213                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14214                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14215                 if (r->in.req == NULL) {
14216                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14217                 }
14218                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14219                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14220         }
14221         if (flags & NDR_OUT) {
14222                 if (r->out.level_out == NULL) {
14223                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14224                 }
14225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14226                 if (r->out.ctr == NULL) {
14227                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14228                 }
14229                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14230                 NDR_CHECK(ndr_push_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14231                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14232         }
14233         return NDR_ERR_SUCCESS;
14234 }
14235
14236 static enum ndr_err_code ndr_pull_drsuapi_DsCrackNames(struct ndr_pull *ndr, int flags, struct drsuapi_DsCrackNames *r)
14237 {
14238         TALLOC_CTX *_mem_save_bind_handle_0;
14239         TALLOC_CTX *_mem_save_req_0;
14240         TALLOC_CTX *_mem_save_level_out_0;
14241         TALLOC_CTX *_mem_save_ctr_0;
14242         if (flags & NDR_IN) {
14243                 ZERO_STRUCT(r->out);
14244
14245                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14246                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14247                 }
14248                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14249                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14250                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14251                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14253                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14254                         NDR_PULL_ALLOC(ndr, r->in.req);
14255                 }
14256                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14257                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14258                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14259                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14260                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14261                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14262                 ZERO_STRUCTP(r->out.level_out);
14263                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14264                 ZERO_STRUCTP(r->out.ctr);
14265         }
14266         if (flags & NDR_OUT) {
14267                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14268                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14269                 }
14270                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14271                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14272                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14273                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14274                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14275                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14276                 }
14277                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14278                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14279                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14280                 NDR_CHECK(ndr_pull_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14281                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14282                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14283         }
14284         return NDR_ERR_SUCCESS;
14285 }
14286
14287 _PUBLIC_ void ndr_print_drsuapi_DsCrackNames(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsCrackNames *r)
14288 {
14289         ndr_print_struct(ndr, name, "drsuapi_DsCrackNames");
14290         ndr->depth++;
14291         if (flags & NDR_SET_VALUES) {
14292                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14293         }
14294         if (flags & NDR_IN) {
14295                 ndr_print_struct(ndr, "in", "drsuapi_DsCrackNames");
14296                 ndr->depth++;
14297                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14298                 ndr->depth++;
14299                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14300                 ndr->depth--;
14301                 ndr_print_uint32(ndr, "level", r->in.level);
14302                 ndr_print_ptr(ndr, "req", r->in.req);
14303                 ndr->depth++;
14304                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14305                 ndr_print_drsuapi_DsNameRequest(ndr, "req", r->in.req);
14306                 ndr->depth--;
14307                 ndr->depth--;
14308         }
14309         if (flags & NDR_OUT) {
14310                 ndr_print_struct(ndr, "out", "drsuapi_DsCrackNames");
14311                 ndr->depth++;
14312                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14313                 ndr->depth++;
14314                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14315                 ndr->depth--;
14316                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14317                 ndr->depth++;
14318                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14319                 ndr_print_drsuapi_DsNameCtr(ndr, "ctr", r->out.ctr);
14320                 ndr->depth--;
14321                 ndr_print_WERROR(ndr, "result", r->out.result);
14322                 ndr->depth--;
14323         }
14324         ndr->depth--;
14325 }
14326
14327 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpn(struct ndr_push *ndr, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14328 {
14329         if (flags & NDR_IN) {
14330                 if (r->in.bind_handle == NULL) {
14331                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14332                 }
14333                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14335                 if (r->in.req == NULL) {
14336                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14337                 }
14338                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14339                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14340         }
14341         if (flags & NDR_OUT) {
14342                 if (r->out.level_out == NULL) {
14343                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14344                 }
14345                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14346                 if (r->out.res == NULL) {
14347                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14348                 }
14349                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14350                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14351                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14352         }
14353         return NDR_ERR_SUCCESS;
14354 }
14355
14356 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpn(struct ndr_pull *ndr, int flags, struct drsuapi_DsWriteAccountSpn *r)
14357 {
14358         TALLOC_CTX *_mem_save_bind_handle_0;
14359         TALLOC_CTX *_mem_save_req_0;
14360         TALLOC_CTX *_mem_save_level_out_0;
14361         TALLOC_CTX *_mem_save_res_0;
14362         if (flags & NDR_IN) {
14363                 ZERO_STRUCT(r->out);
14364
14365                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14366                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14367                 }
14368                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14369                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14370                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14371                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14373                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14374                         NDR_PULL_ALLOC(ndr, r->in.req);
14375                 }
14376                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14377                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14378                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14379                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14380                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14381                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14382                 ZERO_STRUCTP(r->out.level_out);
14383                 NDR_PULL_ALLOC(ndr, r->out.res);
14384                 ZERO_STRUCTP(r->out.res);
14385         }
14386         if (flags & NDR_OUT) {
14387                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14388                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14389                 }
14390                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14391                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14392                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14393                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14394                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14395                         NDR_PULL_ALLOC(ndr, r->out.res);
14396                 }
14397                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14398                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14399                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14400                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14401                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14402                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14403         }
14404         return NDR_ERR_SUCCESS;
14405 }
14406
14407 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpn(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14408 {
14409         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpn");
14410         ndr->depth++;
14411         if (flags & NDR_SET_VALUES) {
14412                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14413         }
14414         if (flags & NDR_IN) {
14415                 ndr_print_struct(ndr, "in", "drsuapi_DsWriteAccountSpn");
14416                 ndr->depth++;
14417                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14418                 ndr->depth++;
14419                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14420                 ndr->depth--;
14421                 ndr_print_uint32(ndr, "level", r->in.level);
14422                 ndr_print_ptr(ndr, "req", r->in.req);
14423                 ndr->depth++;
14424                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14425                 ndr_print_drsuapi_DsWriteAccountSpnRequest(ndr, "req", r->in.req);
14426                 ndr->depth--;
14427                 ndr->depth--;
14428         }
14429         if (flags & NDR_OUT) {
14430                 ndr_print_struct(ndr, "out", "drsuapi_DsWriteAccountSpn");
14431                 ndr->depth++;
14432                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14433                 ndr->depth++;
14434                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14435                 ndr->depth--;
14436                 ndr_print_ptr(ndr, "res", r->out.res);
14437                 ndr->depth++;
14438                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14439                 ndr_print_drsuapi_DsWriteAccountSpnResult(ndr, "res", r->out.res);
14440                 ndr->depth--;
14441                 ndr_print_WERROR(ndr, "result", r->out.result);
14442                 ndr->depth--;
14443         }
14444         ndr->depth--;
14445 }
14446
14447 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServer(struct ndr_push *ndr, int flags, const struct drsuapi_DsRemoveDSServer *r)
14448 {
14449         if (flags & NDR_IN) {
14450                 if (r->in.bind_handle == NULL) {
14451                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14452                 }
14453                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14454                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14455                 if (r->in.req == NULL) {
14456                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14457                 }
14458                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14459                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14460         }
14461         if (flags & NDR_OUT) {
14462                 if (r->out.level_out == NULL) {
14463                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14464                 }
14465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14466                 if (r->out.res == NULL) {
14467                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14468                 }
14469                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14470                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14471                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14472         }
14473         return NDR_ERR_SUCCESS;
14474 }
14475
14476 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServer(struct ndr_pull *ndr, int flags, struct drsuapi_DsRemoveDSServer *r)
14477 {
14478         TALLOC_CTX *_mem_save_bind_handle_0;
14479         TALLOC_CTX *_mem_save_req_0;
14480         TALLOC_CTX *_mem_save_level_out_0;
14481         TALLOC_CTX *_mem_save_res_0;
14482         if (flags & NDR_IN) {
14483                 ZERO_STRUCT(r->out);
14484
14485                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14486                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14487                 }
14488                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14489                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14490                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14491                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14493                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14494                         NDR_PULL_ALLOC(ndr, r->in.req);
14495                 }
14496                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14497                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14498                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14499                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14500                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14501                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14502                 ZERO_STRUCTP(r->out.level_out);
14503                 NDR_PULL_ALLOC(ndr, r->out.res);
14504                 ZERO_STRUCTP(r->out.res);
14505         }
14506         if (flags & NDR_OUT) {
14507                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14508                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14509                 }
14510                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14511                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14512                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14513                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14514                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14515                         NDR_PULL_ALLOC(ndr, r->out.res);
14516                 }
14517                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14518                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14519                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14520                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14521                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14522                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14523         }
14524         return NDR_ERR_SUCCESS;
14525 }
14526
14527 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServer(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsRemoveDSServer *r)
14528 {
14529         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServer");
14530         ndr->depth++;
14531         if (flags & NDR_SET_VALUES) {
14532                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14533         }
14534         if (flags & NDR_IN) {
14535                 ndr_print_struct(ndr, "in", "drsuapi_DsRemoveDSServer");
14536                 ndr->depth++;
14537                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14538                 ndr->depth++;
14539                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14540                 ndr->depth--;
14541                 ndr_print_uint32(ndr, "level", r->in.level);
14542                 ndr_print_ptr(ndr, "req", r->in.req);
14543                 ndr->depth++;
14544                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14545                 ndr_print_drsuapi_DsRemoveDSServerRequest(ndr, "req", r->in.req);
14546                 ndr->depth--;
14547                 ndr->depth--;
14548         }
14549         if (flags & NDR_OUT) {
14550                 ndr_print_struct(ndr, "out", "drsuapi_DsRemoveDSServer");
14551                 ndr->depth++;
14552                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14553                 ndr->depth++;
14554                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14555                 ndr->depth--;
14556                 ndr_print_ptr(ndr, "res", r->out.res);
14557                 ndr->depth++;
14558                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14559                 ndr_print_drsuapi_DsRemoveDSServerResult(ndr, "res", r->out.res);
14560                 ndr->depth--;
14561                 ndr_print_WERROR(ndr, "result", r->out.result);
14562                 ndr->depth--;
14563         }
14564         ndr->depth--;
14565 }
14566
14567 static enum ndr_err_code ndr_push_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_push *ndr, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14568 {
14569         if (flags & NDR_IN) {
14570         }
14571         if (flags & NDR_OUT) {
14572                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14573         }
14574         return NDR_ERR_SUCCESS;
14575 }
14576
14577 static enum ndr_err_code ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_pull *ndr, int flags, struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14578 {
14579         if (flags & NDR_IN) {
14580         }
14581         if (flags & NDR_OUT) {
14582                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14583         }
14584         return NDR_ERR_SUCCESS;
14585 }
14586
14587 _PUBLIC_ void ndr_print_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14588 {
14589         ndr_print_struct(ndr, name, "DRSUAPI_REMOVE_DS_DOMAIN");
14590         ndr->depth++;
14591         if (flags & NDR_SET_VALUES) {
14592                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14593         }
14594         if (flags & NDR_IN) {
14595                 ndr_print_struct(ndr, "in", "DRSUAPI_REMOVE_DS_DOMAIN");
14596                 ndr->depth++;
14597                 ndr->depth--;
14598         }
14599         if (flags & NDR_OUT) {
14600                 ndr_print_struct(ndr, "out", "DRSUAPI_REMOVE_DS_DOMAIN");
14601                 ndr->depth++;
14602                 ndr_print_WERROR(ndr, "result", r->out.result);
14603                 ndr->depth--;
14604         }
14605         ndr->depth--;
14606 }
14607
14608 static enum ndr_err_code ndr_push_drsuapi_DsGetDomainControllerInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14609 {
14610         if (flags & NDR_IN) {
14611                 if (r->in.bind_handle == NULL) {
14612                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14613                 }
14614                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14615                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14616                 if (r->in.req == NULL) {
14617                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14618                 }
14619                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14620                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14621         }
14622         if (flags & NDR_OUT) {
14623                 if (r->out.level_out == NULL) {
14624                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14625                 }
14626                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14627                 if (r->out.ctr == NULL) {
14628                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14629                 }
14630                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14631                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14632                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14633         }
14634         return NDR_ERR_SUCCESS;
14635 }
14636
14637 static enum ndr_err_code ndr_pull_drsuapi_DsGetDomainControllerInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetDomainControllerInfo *r)
14638 {
14639         TALLOC_CTX *_mem_save_bind_handle_0;
14640         TALLOC_CTX *_mem_save_req_0;
14641         TALLOC_CTX *_mem_save_level_out_0;
14642         TALLOC_CTX *_mem_save_ctr_0;
14643         if (flags & NDR_IN) {
14644                 ZERO_STRUCT(r->out);
14645
14646                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14647                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14648                 }
14649                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14650                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14651                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14652                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14653                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14654                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14655                         NDR_PULL_ALLOC(ndr, r->in.req);
14656                 }
14657                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14658                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14659                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14660                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14661                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14662                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14663                 ZERO_STRUCTP(r->out.level_out);
14664                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14665                 ZERO_STRUCTP(r->out.ctr);
14666         }
14667         if (flags & NDR_OUT) {
14668                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14669                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14670                 }
14671                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14672                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14673                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14674                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14675                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14676                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14677                 }
14678                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14679                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14680                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14681                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14682                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14683                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14684         }
14685         return NDR_ERR_SUCCESS;
14686 }
14687
14688 _PUBLIC_ void ndr_print_drsuapi_DsGetDomainControllerInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14689 {
14690         ndr_print_struct(ndr, name, "drsuapi_DsGetDomainControllerInfo");
14691         ndr->depth++;
14692         if (flags & NDR_SET_VALUES) {
14693                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14694         }
14695         if (flags & NDR_IN) {
14696                 ndr_print_struct(ndr, "in", "drsuapi_DsGetDomainControllerInfo");
14697                 ndr->depth++;
14698                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14699                 ndr->depth++;
14700                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14701                 ndr->depth--;
14702                 ndr_print_int32(ndr, "level", r->in.level);
14703                 ndr_print_ptr(ndr, "req", r->in.req);
14704                 ndr->depth++;
14705                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14706                 ndr_print_drsuapi_DsGetDCInfoRequest(ndr, "req", r->in.req);
14707                 ndr->depth--;
14708                 ndr->depth--;
14709         }
14710         if (flags & NDR_OUT) {
14711                 ndr_print_struct(ndr, "out", "drsuapi_DsGetDomainControllerInfo");
14712                 ndr->depth++;
14713                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14714                 ndr->depth++;
14715                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14716                 ndr->depth--;
14717                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14718                 ndr->depth++;
14719                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14720                 ndr_print_drsuapi_DsGetDCInfoCtr(ndr, "ctr", r->out.ctr);
14721                 ndr->depth--;
14722                 ndr_print_WERROR(ndr, "result", r->out.result);
14723                 ndr->depth--;
14724         }
14725         ndr->depth--;
14726 }
14727
14728 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAddEntry(struct ndr_push *ndr, int flags, const struct drsuapi_DsAddEntry *r)
14729 {
14730         if (flags & NDR_IN) {
14731                 if (r->in.bind_handle == NULL) {
14732                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14733                 }
14734                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14735                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14736                 if (r->in.req == NULL) {
14737                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14738                 }
14739                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14740                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14741         }
14742         if (flags & NDR_OUT) {
14743                 if (r->out.level_out == NULL) {
14744                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14745                 }
14746                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14747                 if (r->out.ctr == NULL) {
14748                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14749                 }
14750                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14751                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14752                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14753         }
14754         return NDR_ERR_SUCCESS;
14755 }
14756
14757 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAddEntry(struct ndr_pull *ndr, int flags, struct drsuapi_DsAddEntry *r)
14758 {
14759         TALLOC_CTX *_mem_save_bind_handle_0;
14760         TALLOC_CTX *_mem_save_req_0;
14761         TALLOC_CTX *_mem_save_level_out_0;
14762         TALLOC_CTX *_mem_save_ctr_0;
14763         if (flags & NDR_IN) {
14764                 ZERO_STRUCT(r->out);
14765
14766                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14767                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14768                 }
14769                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14770                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14771                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14772                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14773                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14774                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14775                         NDR_PULL_ALLOC(ndr, r->in.req);
14776                 }
14777                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14778                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14779                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14780                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14781                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14782                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14783                 ZERO_STRUCTP(r->out.level_out);
14784                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14785                 ZERO_STRUCTP(r->out.ctr);
14786         }
14787         if (flags & NDR_OUT) {
14788                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14789                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14790                 }
14791                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14792                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14793                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14794                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14795                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14796                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14797                 }
14798                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14799                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14800                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14801                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14802                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14803                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14804         }
14805         return NDR_ERR_SUCCESS;
14806 }
14807
14808 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsAddEntry *r)
14809 {
14810         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry");
14811         ndr->depth++;
14812         if (flags & NDR_SET_VALUES) {
14813                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14814         }
14815         if (flags & NDR_IN) {
14816                 ndr_print_struct(ndr, "in", "drsuapi_DsAddEntry");
14817                 ndr->depth++;
14818                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14819                 ndr->depth++;
14820                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14821                 ndr->depth--;
14822                 ndr_print_int32(ndr, "level", r->in.level);
14823                 ndr_print_ptr(ndr, "req", r->in.req);
14824                 ndr->depth++;
14825                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14826                 ndr_print_drsuapi_DsAddEntryRequest(ndr, "req", r->in.req);
14827                 ndr->depth--;
14828                 ndr->depth--;
14829         }
14830         if (flags & NDR_OUT) {
14831                 ndr_print_struct(ndr, "out", "drsuapi_DsAddEntry");
14832                 ndr->depth++;
14833                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14834                 ndr->depth++;
14835                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14836                 ndr->depth--;
14837                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14838                 ndr->depth++;
14839                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14840                 ndr_print_drsuapi_DsAddEntryCtr(ndr, "ctr", r->out.ctr);
14841                 ndr->depth--;
14842                 ndr_print_WERROR(ndr, "result", r->out.result);
14843                 ndr->depth--;
14844         }
14845         ndr->depth--;
14846 }
14847
14848 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC(struct ndr_push *ndr, int flags, const struct drsuapi_DsExecuteKCC *r)
14849 {
14850         if (flags & NDR_IN) {
14851                 if (r->in.bind_handle == NULL) {
14852                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14853                 }
14854                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14856                 if (r->in.req == NULL) {
14857                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14858                 }
14859                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14860                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14861         }
14862         if (flags & NDR_OUT) {
14863                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14864         }
14865         return NDR_ERR_SUCCESS;
14866 }
14867
14868 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC(struct ndr_pull *ndr, int flags, struct drsuapi_DsExecuteKCC *r)
14869 {
14870         TALLOC_CTX *_mem_save_bind_handle_0;
14871         TALLOC_CTX *_mem_save_req_0;
14872         if (flags & NDR_IN) {
14873                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14874                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14875                 }
14876                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14877                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14878                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14879                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14880                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14881                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14882                         NDR_PULL_ALLOC(ndr, r->in.req);
14883                 }
14884                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14885                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14886                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14887                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14888                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14889         }
14890         if (flags & NDR_OUT) {
14891                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14892         }
14893         return NDR_ERR_SUCCESS;
14894 }
14895
14896 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsExecuteKCC *r)
14897 {
14898         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC");
14899         ndr->depth++;
14900         if (flags & NDR_SET_VALUES) {
14901                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14902         }
14903         if (flags & NDR_IN) {
14904                 ndr_print_struct(ndr, "in", "drsuapi_DsExecuteKCC");
14905                 ndr->depth++;
14906                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14907                 ndr->depth++;
14908                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14909                 ndr->depth--;
14910                 ndr_print_uint32(ndr, "level", r->in.level);
14911                 ndr_print_ptr(ndr, "req", r->in.req);
14912                 ndr->depth++;
14913                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14914                 ndr_print_drsuapi_DsExecuteKCCRequest(ndr, "req", r->in.req);
14915                 ndr->depth--;
14916                 ndr->depth--;
14917         }
14918         if (flags & NDR_OUT) {
14919                 ndr_print_struct(ndr, "out", "drsuapi_DsExecuteKCC");
14920                 ndr->depth++;
14921                 ndr_print_WERROR(ndr, "result", r->out.result);
14922                 ndr->depth--;
14923         }
14924         ndr->depth--;
14925 }
14926
14927 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaGetInfo *r)
14928 {
14929         if (flags & NDR_IN) {
14930                 if (r->in.bind_handle == NULL) {
14931                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14932                 }
14933                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14934                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, r->in.level));
14935                 if (r->in.req == NULL) {
14936                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14937                 }
14938                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14939                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14940         }
14941         if (flags & NDR_OUT) {
14942                 if (r->out.info_type == NULL) {
14943                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14944                 }
14945                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, *r->out.info_type));
14946                 if (r->out.info == NULL) {
14947                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14948                 }
14949                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.info_type));
14950                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14951                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14952         }
14953         return NDR_ERR_SUCCESS;
14954 }
14955
14956 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaGetInfo *r)
14957 {
14958         TALLOC_CTX *_mem_save_bind_handle_0;
14959         TALLOC_CTX *_mem_save_req_0;
14960         TALLOC_CTX *_mem_save_info_type_0;
14961         TALLOC_CTX *_mem_save_info_0;
14962         if (flags & NDR_IN) {
14963                 ZERO_STRUCT(r->out);
14964
14965                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14966                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14967                 }
14968                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14969                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14970                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14971                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14972                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, &r->in.level));
14973                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14974                         NDR_PULL_ALLOC(ndr, r->in.req);
14975                 }
14976                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14977                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14978                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14979                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14980                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14981                 NDR_PULL_ALLOC(ndr, r->out.info_type);
14982                 ZERO_STRUCTP(r->out.info_type);
14983                 NDR_PULL_ALLOC(ndr, r->out.info);
14984                 ZERO_STRUCTP(r->out.info);
14985         }
14986         if (flags & NDR_OUT) {
14987                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14988                         NDR_PULL_ALLOC(ndr, r->out.info_type);
14989                 }
14990                 _mem_save_info_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
14991                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_type, LIBNDR_FLAG_REF_ALLOC);
14992                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->out.info_type));
14993                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_type_0, LIBNDR_FLAG_REF_ALLOC);
14994                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14995                         NDR_PULL_ALLOC(ndr, r->out.info);
14996                 }
14997                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14998                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14999                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.info_type));
15000                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15001                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15002                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15003         }
15004         return NDR_ERR_SUCCESS;
15005 }
15006
15007 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaGetInfo *r)
15008 {
15009         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfo");
15010         ndr->depth++;
15011         if (flags & NDR_SET_VALUES) {
15012                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15013         }
15014         if (flags & NDR_IN) {
15015                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaGetInfo");
15016                 ndr->depth++;
15017                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15018                 ndr->depth++;
15019                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15020                 ndr->depth--;
15021                 ndr_print_drsuapi_DsReplicaGetInfoLevel(ndr, "level", r->in.level);
15022                 ndr_print_ptr(ndr, "req", r->in.req);
15023                 ndr->depth++;
15024                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15025                 ndr_print_drsuapi_DsReplicaGetInfoRequest(ndr, "req", r->in.req);
15026                 ndr->depth--;
15027                 ndr->depth--;
15028         }
15029         if (flags & NDR_OUT) {
15030                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaGetInfo");
15031                 ndr->depth++;
15032                 ndr_print_ptr(ndr, "info_type", r->out.info_type);
15033                 ndr->depth++;
15034                 ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", *r->out.info_type);
15035                 ndr->depth--;
15036                 ndr_print_ptr(ndr, "info", r->out.info);
15037                 ndr->depth++;
15038                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.info_type);
15039                 ndr_print_drsuapi_DsReplicaInfo(ndr, "info", r->out.info);
15040                 ndr->depth--;
15041                 ndr_print_WERROR(ndr, "result", r->out.result);
15042                 ndr->depth--;
15043         }
15044         ndr->depth--;
15045 }
15046
15047 static enum ndr_err_code ndr_push_DRSUAPI_ADD_SID_HISTORY(struct ndr_push *ndr, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15048 {
15049         if (flags & NDR_IN) {
15050         }
15051         if (flags & NDR_OUT) {
15052                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15053         }
15054         return NDR_ERR_SUCCESS;
15055 }
15056
15057 static enum ndr_err_code ndr_pull_DRSUAPI_ADD_SID_HISTORY(struct ndr_pull *ndr, int flags, struct DRSUAPI_ADD_SID_HISTORY *r)
15058 {
15059         if (flags & NDR_IN) {
15060         }
15061         if (flags & NDR_OUT) {
15062                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15063         }
15064         return NDR_ERR_SUCCESS;
15065 }
15066
15067 _PUBLIC_ void ndr_print_DRSUAPI_ADD_SID_HISTORY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15068 {
15069         ndr_print_struct(ndr, name, "DRSUAPI_ADD_SID_HISTORY");
15070         ndr->depth++;
15071         if (flags & NDR_SET_VALUES) {
15072                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15073         }
15074         if (flags & NDR_IN) {
15075                 ndr_print_struct(ndr, "in", "DRSUAPI_ADD_SID_HISTORY");
15076                 ndr->depth++;
15077                 ndr->depth--;
15078         }
15079         if (flags & NDR_OUT) {
15080                 ndr_print_struct(ndr, "out", "DRSUAPI_ADD_SID_HISTORY");
15081                 ndr->depth++;
15082                 ndr_print_WERROR(ndr, "result", r->out.result);
15083                 ndr->depth--;
15084         }
15085         ndr->depth--;
15086 }
15087
15088 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships2 *r)
15089 {
15090         if (flags & NDR_IN) {
15091                 if (r->in.bind_handle == NULL) {
15092                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15093                 }
15094                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15096                 if (r->in.req == NULL) {
15097                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15098                 }
15099                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15100                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15101         }
15102         if (flags & NDR_OUT) {
15103                 if (r->out.level_out == NULL) {
15104                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15105                 }
15106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
15107                 if (r->out.ctr == NULL) {
15108                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15109                 }
15110                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15111                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15112                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15113         }
15114         return NDR_ERR_SUCCESS;
15115 }
15116
15117 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships2 *r)
15118 {
15119         TALLOC_CTX *_mem_save_bind_handle_0;
15120         TALLOC_CTX *_mem_save_req_0;
15121         TALLOC_CTX *_mem_save_level_out_0;
15122         TALLOC_CTX *_mem_save_ctr_0;
15123         if (flags & NDR_IN) {
15124                 ZERO_STRUCT(r->out);
15125
15126                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15127                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15128                 }
15129                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15130                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15131                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15132                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15134                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15135                         NDR_PULL_ALLOC(ndr, r->in.req);
15136                 }
15137                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15138                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15139                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15140                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15141                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15142                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15143                 ZERO_STRUCTP(r->out.level_out);
15144                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15145                 ZERO_STRUCTP(r->out.ctr);
15146         }
15147         if (flags & NDR_OUT) {
15148                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15149                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15150                 }
15151                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15152                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
15154                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15155                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15156                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15157                 }
15158                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15159                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15160                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15161                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15162                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15163                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15164         }
15165         return NDR_ERR_SUCCESS;
15166 }
15167
15168 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships2 *r)
15169 {
15170         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2");
15171         ndr->depth++;
15172         if (flags & NDR_SET_VALUES) {
15173                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15174         }
15175         if (flags & NDR_IN) {
15176                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships2");
15177                 ndr->depth++;
15178                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15179                 ndr->depth++;
15180                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15181                 ndr->depth--;
15182                 ndr_print_uint32(ndr, "level", r->in.level);
15183                 ndr_print_ptr(ndr, "req", r->in.req);
15184                 ndr->depth++;
15185                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15186                 ndr_print_drsuapi_DsGetMemberships2Request(ndr, "req", r->in.req);
15187                 ndr->depth--;
15188                 ndr->depth--;
15189         }
15190         if (flags & NDR_OUT) {
15191                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships2");
15192                 ndr->depth++;
15193                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15194                 ndr->depth++;
15195                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
15196                 ndr->depth--;
15197                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15198                 ndr->depth++;
15199                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15200                 ndr_print_drsuapi_DsGetMemberships2Ctr(ndr, "ctr", r->out.ctr);
15201                 ndr->depth--;
15202                 ndr_print_WERROR(ndr, "result", r->out.result);
15203                 ndr->depth--;
15204         }
15205         ndr->depth--;
15206 }
15207
15208 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15209 {
15210         if (flags & NDR_IN) {
15211         }
15212         if (flags & NDR_OUT) {
15213                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15214         }
15215         return NDR_ERR_SUCCESS;
15216 }
15217
15218 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15219 {
15220         if (flags & NDR_IN) {
15221         }
15222         if (flags & NDR_OUT) {
15223                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15224         }
15225         return NDR_ERR_SUCCESS;
15226 }
15227
15228 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15229 {
15230         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15231         ndr->depth++;
15232         if (flags & NDR_SET_VALUES) {
15233                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15234         }
15235         if (flags & NDR_IN) {
15236                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15237                 ndr->depth++;
15238                 ndr->depth--;
15239         }
15240         if (flags & NDR_OUT) {
15241                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15242                 ndr->depth++;
15243                 ndr_print_WERROR(ndr, "result", r->out.result);
15244                 ndr->depth--;
15245         }
15246         ndr->depth--;
15247 }
15248
15249 static enum ndr_err_code ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_push *ndr, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15250 {
15251         if (flags & NDR_IN) {
15252         }
15253         if (flags & NDR_OUT) {
15254                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15255         }
15256         return NDR_ERR_SUCCESS;
15257 }
15258
15259 static enum ndr_err_code ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_pull *ndr, int flags, struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15260 {
15261         if (flags & NDR_IN) {
15262         }
15263         if (flags & NDR_OUT) {
15264                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15265         }
15266         return NDR_ERR_SUCCESS;
15267 }
15268
15269 _PUBLIC_ void ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15270 {
15271         ndr_print_struct(ndr, name, "DRSUAPI_GET_OBJECT_EXISTENCE");
15272         ndr->depth++;
15273         if (flags & NDR_SET_VALUES) {
15274                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15275         }
15276         if (flags & NDR_IN) {
15277                 ndr_print_struct(ndr, "in", "DRSUAPI_GET_OBJECT_EXISTENCE");
15278                 ndr->depth++;
15279                 ndr->depth--;
15280         }
15281         if (flags & NDR_OUT) {
15282                 ndr_print_struct(ndr, "out", "DRSUAPI_GET_OBJECT_EXISTENCE");
15283                 ndr->depth++;
15284                 ndr_print_WERROR(ndr, "result", r->out.result);
15285                 ndr->depth--;
15286         }
15287         ndr->depth--;
15288 }
15289
15290 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCost(struct ndr_push *ndr, int flags, const struct drsuapi_QuerySitesByCost *r)
15291 {
15292         if (flags & NDR_IN) {
15293                 if (r->in.bind_handle == NULL) {
15294                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15295                 }
15296                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15298                 if (r->in.req == NULL) {
15299                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15300                 }
15301                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15302                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15303         }
15304         if (flags & NDR_OUT) {
15305                 if (r->out.level_out == NULL) {
15306                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15307                 }
15308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
15309                 if (r->out.ctr == NULL) {
15310                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15311                 }
15312                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15313                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15314                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15315         }
15316         return NDR_ERR_SUCCESS;
15317 }
15318
15319 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCost(struct ndr_pull *ndr, int flags, struct drsuapi_QuerySitesByCost *r)
15320 {
15321         TALLOC_CTX *_mem_save_bind_handle_0;
15322         TALLOC_CTX *_mem_save_req_0;
15323         TALLOC_CTX *_mem_save_level_out_0;
15324         TALLOC_CTX *_mem_save_ctr_0;
15325         if (flags & NDR_IN) {
15326                 ZERO_STRUCT(r->out);
15327
15328                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15329                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15330                 }
15331                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15332                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15333                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15334                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15336                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15337                         NDR_PULL_ALLOC(ndr, r->in.req);
15338                 }
15339                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15340                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15341                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15342                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15343                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15344                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15345                 ZERO_STRUCTP(r->out.level_out);
15346                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15347                 ZERO_STRUCTP(r->out.ctr);
15348         }
15349         if (flags & NDR_OUT) {
15350                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15351                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15352                 }
15353                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15354                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
15356                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15357                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15358                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15359                 }
15360                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15361                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15362                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15363                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15364                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15365                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15366         }
15367         return NDR_ERR_SUCCESS;
15368 }
15369
15370 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCost(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_QuerySitesByCost *r)
15371 {
15372         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCost");
15373         ndr->depth++;
15374         if (flags & NDR_SET_VALUES) {
15375                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15376         }
15377         if (flags & NDR_IN) {
15378                 ndr_print_struct(ndr, "in", "drsuapi_QuerySitesByCost");
15379                 ndr->depth++;
15380                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15381                 ndr->depth++;
15382                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15383                 ndr->depth--;
15384                 ndr_print_uint32(ndr, "level", r->in.level);
15385                 ndr_print_ptr(ndr, "req", r->in.req);
15386                 ndr->depth++;
15387                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15388                 ndr_print_drsuapi_QuerySitesByCostRequest(ndr, "req", r->in.req);
15389                 ndr->depth--;
15390                 ndr->depth--;
15391         }
15392         if (flags & NDR_OUT) {
15393                 ndr_print_struct(ndr, "out", "drsuapi_QuerySitesByCost");
15394                 ndr->depth++;
15395                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15396                 ndr->depth++;
15397                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
15398                 ndr->depth--;
15399                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15400                 ndr->depth++;
15401                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15402                 ndr_print_drsuapi_QuerySitesByCostCtr(ndr, "ctr", r->out.ctr);
15403                 ndr->depth--;
15404                 ndr_print_WERROR(ndr, "result", r->out.result);
15405                 ndr->depth--;
15406         }
15407         ndr->depth--;
15408 }
15409
15410 static const struct ndr_interface_call drsuapi_calls[] = {
15411         {
15412                 "drsuapi_DsBind",
15413                 sizeof(struct drsuapi_DsBind),
15414                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsBind,
15415                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsBind,
15416                 (ndr_print_function_t) ndr_print_drsuapi_DsBind,
15417                 false,
15418         },
15419         {
15420                 "drsuapi_DsUnbind",
15421                 sizeof(struct drsuapi_DsUnbind),
15422                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsUnbind,
15423                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsUnbind,
15424                 (ndr_print_function_t) ndr_print_drsuapi_DsUnbind,
15425                 false,
15426         },
15427         {
15428                 "drsuapi_DsReplicaSync",
15429                 sizeof(struct drsuapi_DsReplicaSync),
15430                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaSync,
15431                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaSync,
15432                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaSync,
15433                 false,
15434         },
15435         {
15436                 "drsuapi_DsGetNCChanges",
15437                 sizeof(struct drsuapi_DsGetNCChanges),
15438                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNCChanges,
15439                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNCChanges,
15440                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNCChanges,
15441                 false,
15442         },
15443         {
15444                 "drsuapi_DsReplicaUpdateRefs",
15445                 sizeof(struct drsuapi_DsReplicaUpdateRefs),
15446                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaUpdateRefs,
15447                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaUpdateRefs,
15448                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaUpdateRefs,
15449                 false,
15450         },
15451         {
15452                 "drsuapi_DsReplicaAdd",
15453                 sizeof(struct drsuapi_DsReplicaAdd),
15454                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaAdd,
15455                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaAdd,
15456                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaAdd,
15457                 false,
15458         },
15459         {
15460                 "drsuapi_DsReplicaDel",
15461                 sizeof(struct drsuapi_DsReplicaDel),
15462                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaDel,
15463                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaDel,
15464                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaDel,
15465                 false,
15466         },
15467         {
15468                 "drsuapi_DsReplicaMod",
15469                 sizeof(struct drsuapi_DsReplicaMod),
15470                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaMod,
15471                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaMod,
15472                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaMod,
15473                 false,
15474         },
15475         {
15476                 "DRSUAPI_VERIFY_NAMES",
15477                 sizeof(struct DRSUAPI_VERIFY_NAMES),
15478                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_VERIFY_NAMES,
15479                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_VERIFY_NAMES,
15480                 (ndr_print_function_t) ndr_print_DRSUAPI_VERIFY_NAMES,
15481                 false,
15482         },
15483         {
15484                 "drsuapi_DsGetMemberships",
15485                 sizeof(struct drsuapi_DsGetMemberships),
15486                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships,
15487                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships,
15488                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships,
15489                 false,
15490         },
15491         {
15492                 "DRSUAPI_INTER_DOMAIN_MOVE",
15493                 sizeof(struct DRSUAPI_INTER_DOMAIN_MOVE),
15494                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_INTER_DOMAIN_MOVE,
15495                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE,
15496                 (ndr_print_function_t) ndr_print_DRSUAPI_INTER_DOMAIN_MOVE,
15497                 false,
15498         },
15499         {
15500                 "drsuapi_DsGetNT4ChangeLog",
15501                 sizeof(struct drsuapi_DsGetNT4ChangeLog),
15502                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNT4ChangeLog,
15503                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNT4ChangeLog,
15504                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNT4ChangeLog,
15505                 false,
15506         },
15507         {
15508                 "drsuapi_DsCrackNames",
15509                 sizeof(struct drsuapi_DsCrackNames),
15510                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsCrackNames,
15511                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsCrackNames,
15512                 (ndr_print_function_t) ndr_print_drsuapi_DsCrackNames,
15513                 false,
15514         },
15515         {
15516                 "drsuapi_DsWriteAccountSpn",
15517                 sizeof(struct drsuapi_DsWriteAccountSpn),
15518                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsWriteAccountSpn,
15519                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsWriteAccountSpn,
15520                 (ndr_print_function_t) ndr_print_drsuapi_DsWriteAccountSpn,
15521                 false,
15522         },
15523         {
15524                 "drsuapi_DsRemoveDSServer",
15525                 sizeof(struct drsuapi_DsRemoveDSServer),
15526                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsRemoveDSServer,
15527                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsRemoveDSServer,
15528                 (ndr_print_function_t) ndr_print_drsuapi_DsRemoveDSServer,
15529                 false,
15530         },
15531         {
15532                 "DRSUAPI_REMOVE_DS_DOMAIN",
15533                 sizeof(struct DRSUAPI_REMOVE_DS_DOMAIN),
15534                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REMOVE_DS_DOMAIN,
15535                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN,
15536                 (ndr_print_function_t) ndr_print_DRSUAPI_REMOVE_DS_DOMAIN,
15537                 false,
15538         },
15539         {
15540                 "drsuapi_DsGetDomainControllerInfo",
15541                 sizeof(struct drsuapi_DsGetDomainControllerInfo),
15542                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetDomainControllerInfo,
15543                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetDomainControllerInfo,
15544                 (ndr_print_function_t) ndr_print_drsuapi_DsGetDomainControllerInfo,
15545                 false,
15546         },
15547         {
15548                 "drsuapi_DsAddEntry",
15549                 sizeof(struct drsuapi_DsAddEntry),
15550                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsAddEntry,
15551                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsAddEntry,
15552                 (ndr_print_function_t) ndr_print_drsuapi_DsAddEntry,
15553                 false,
15554         },
15555         {
15556                 "drsuapi_DsExecuteKCC",
15557                 sizeof(struct drsuapi_DsExecuteKCC),
15558                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsExecuteKCC,
15559                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsExecuteKCC,
15560                 (ndr_print_function_t) ndr_print_drsuapi_DsExecuteKCC,
15561                 false,
15562         },
15563         {
15564                 "drsuapi_DsReplicaGetInfo",
15565                 sizeof(struct drsuapi_DsReplicaGetInfo),
15566                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaGetInfo,
15567                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaGetInfo,
15568                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaGetInfo,
15569                 false,
15570         },
15571         {
15572                 "DRSUAPI_ADD_SID_HISTORY",
15573                 sizeof(struct DRSUAPI_ADD_SID_HISTORY),
15574                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_ADD_SID_HISTORY,
15575                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_ADD_SID_HISTORY,
15576                 (ndr_print_function_t) ndr_print_DRSUAPI_ADD_SID_HISTORY,
15577                 false,
15578         },
15579         {
15580                 "drsuapi_DsGetMemberships2",
15581                 sizeof(struct drsuapi_DsGetMemberships2),
15582                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships2,
15583                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships2,
15584                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships2,
15585                 false,
15586         },
15587         {
15588                 "DRSUAPI_REPLICA_VERIFY_OBJECTS",
15589                 sizeof(struct DRSUAPI_REPLICA_VERIFY_OBJECTS),
15590                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15591                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15592                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15593                 false,
15594         },
15595         {
15596                 "DRSUAPI_GET_OBJECT_EXISTENCE",
15597                 sizeof(struct DRSUAPI_GET_OBJECT_EXISTENCE),
15598                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE,
15599                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE,
15600                 (ndr_print_function_t) ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE,
15601                 false,
15602         },
15603         {
15604                 "drsuapi_QuerySitesByCost",
15605                 sizeof(struct drsuapi_QuerySitesByCost),
15606                 (ndr_push_flags_fn_t) ndr_push_drsuapi_QuerySitesByCost,
15607                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_QuerySitesByCost,
15608                 (ndr_print_function_t) ndr_print_drsuapi_QuerySitesByCost,
15609                 false,
15610         },
15611         { NULL, 0, NULL, NULL, NULL, false }
15612 };
15613
15614 static const char * const drsuapi_endpoint_strings[] = {
15615         "ncacn_np:[\\pipe\\lsass]",
15616         "ncacn_np:[\\pipe\\protected_storage]",
15617         "ncacn_ip_tcp:",
15618         "ncalrpc:",
15619 };
15620
15621 static const struct ndr_interface_string_array drsuapi_endpoints = {
15622         .count  = 4,
15623         .names  = drsuapi_endpoint_strings
15624 };
15625
15626 static const char * const drsuapi_authservice_strings[] = {
15627         "ldap",
15628 };
15629
15630 static const struct ndr_interface_string_array drsuapi_authservices = {
15631         .count  = 1,
15632         .names  = drsuapi_authservice_strings
15633 };
15634
15635
15636 const struct ndr_interface_table ndr_table_drsuapi = {
15637         .name           = "drsuapi",
15638         .syntax_id      = {
15639                 {0xe3514235,0x4b06,0x11d1,{0xab,0x04},{0x00,0xc0,0x4f,0xc2,0xdc,0xd2}},
15640                 NDR_DRSUAPI_VERSION
15641         },
15642         .helpstring     = NDR_DRSUAPI_HELPSTRING,
15643         .num_calls      = 25,
15644         .calls          = drsuapi_calls,
15645         .endpoints      = &drsuapi_endpoints,
15646         .authservices   = &drsuapi_authservices
15647 };
15648