librpc/gen_ndr/ndr_drsuapi.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_drsuapi.h"
   5
   6 #include "librpc/gen_ndr/ndr_security.h"
   7 #include "librpc/gen_ndr/ndr_misc.h"
   8 #include "librpc/gen_ndr/ndr_samr.h"
   9 #include "librpc/ndr/ndr_compression.h"
  10 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DrsOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  11 {
  12         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  13         return NDR_ERR_SUCCESS;
  14 }
  15
  16 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DrsOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  17 {
  18         uint32_t v;
  19         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  20         *r = v;
  21         return NDR_ERR_SUCCESS;
  22 }
  23
  24 _PUBLIC_ void ndr_print_drsuapi_DrsOptions(struct ndr_print *ndr, const char *name, uint32_t r)
  25 {
  26         ndr_print_uint32(ndr, name, r);
  27         ndr->depth++;
  28         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_ASYNC_OP", DRSUAPI_DRS_ASYNC_OP, r);
  29         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GETCHG_CHECK", DRSUAPI_DRS_GETCHG_CHECK, r);
  30         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_UPDATE_NOTIFICATION", DRSUAPI_DRS_UPDATE_NOTIFICATION, r);
  31         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_ADD_REF", DRSUAPI_DRS_ADD_REF, r);
  32         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_ALL", DRSUAPI_DRS_SYNC_ALL, r);
  33         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DEL_REF", DRSUAPI_DRS_DEL_REF, r);
  34         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_WRIT_REP", DRSUAPI_DRS_WRIT_REP, r);
  35         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_INIT_SYNC", DRSUAPI_DRS_INIT_SYNC, r);
  36         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_PER_SYNC", DRSUAPI_DRS_PER_SYNC, r);
  37         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_MAIL_REP", DRSUAPI_DRS_MAIL_REP, r);
  38         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_ASYNC_REP", DRSUAPI_DRS_ASYNC_REP, r);
  39         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_IGNORE_ERROR", DRSUAPI_DRS_IGNORE_ERROR, r);
  40         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_TWOWAY_SYNC", DRSUAPI_DRS_TWOWAY_SYNC, r);
  41         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_CRITICAL_ONLY", DRSUAPI_DRS_CRITICAL_ONLY, r);
  42         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_ANC", DRSUAPI_DRS_GET_ANC, r);
  43         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_NC_SIZE", DRSUAPI_DRS_GET_NC_SIZE, r);
  44         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_LOCAL_ONLY", DRSUAPI_DRS_LOCAL_ONLY, r);
  45         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NONGC_RO_REP", DRSUAPI_DRS_NONGC_RO_REP, r);
  46         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_BYNAME", DRSUAPI_DRS_SYNC_BYNAME, r);
  47         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_REF_OK", DRSUAPI_DRS_REF_OK, r);
  48         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_NOW", DRSUAPI_DRS_FULL_SYNC_NOW, r);
  49         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NO_SOURCE", DRSUAPI_DRS_NO_SOURCE, r);
  50         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS", DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS, r);
  51         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_PACKET", DRSUAPI_DRS_FULL_SYNC_PACKET, r);
  52         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_REQUEUE", DRSUAPI_DRS_SYNC_REQUEUE, r);
  53         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_URGENT", DRSUAPI_DRS_SYNC_URGENT, r);
  54         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_REF_GCSPN", DRSUAPI_DRS_REF_GCSPN, r);
  55         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NO_DISCARD", DRSUAPI_DRS_NO_DISCARD, r);
  56         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NEVER_SYNCED", DRSUAPI_DRS_NEVER_SYNCED, r);
  57         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING", DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING, r);
  58         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_INIT_SYNC_NOW", DRSUAPI_DRS_INIT_SYNC_NOW, r);
  59         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_PREEMPTED", DRSUAPI_DRS_PREEMPTED, r);
  60         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_FORCED", DRSUAPI_DRS_SYNC_FORCED, r);
  61         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DISABLE_AUTO_SYNC", DRSUAPI_DRS_DISABLE_AUTO_SYNC, r);
  62         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DISABLE_PERIODIC_SYNC", DRSUAPI_DRS_DISABLE_PERIODIC_SYNC, r);
  63         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_USE_COMPRESSION", DRSUAPI_DRS_USE_COMPRESSION, r);
  64         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NEVER_NOTIFY", DRSUAPI_DRS_NEVER_NOTIFY, r);
  65         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_PAS", DRSUAPI_DRS_SYNC_PAS, r);
  66         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_ALL_GROUP_MEMBERSHIP", DRSUAPI_DRS_GET_ALL_GROUP_MEMBERSHIP, r);
  67         ndr->depth--;
  68 }
  69
  70 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  71 {
  72         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  73         return NDR_ERR_SUCCESS;
  74 }
  75
  76 static enum ndr_err_code ndr_pull_drsuapi_SupportedExtensions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  77 {
  78         uint32_t v;
  79         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  80         *r = v;
  81         return NDR_ERR_SUCCESS;
  82 }
  83
  84 _PUBLIC_ void ndr_print_drsuapi_SupportedExtensions(struct ndr_print *ndr, const char *name, uint32_t r)
  85 {
  86         ndr_print_uint32(ndr, name, r);
  87         ndr->depth++;
  88         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_BASE", DRSUAPI_SUPPORTED_EXTENSION_BASE, r);
  89         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION", DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION, r);
  90         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI", DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI, r);
  91         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2", DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2, r);
  92         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS", DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS, r);
  93         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1, r);
  94         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION", DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION, r);
  95         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY, r);
  96         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE", DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE, r);
  97         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2, r);
  98         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION", DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION, r);
  99         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2, r);
 100         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD", DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD, r);
 101         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND", DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND, r);
 102         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO", DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO, r);
 103         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION", DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION, r);
 104         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01, r);
 105         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP", DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP, r);
 106         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY", DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY, r);
 107         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3", DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3, r);
 108         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V5", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V5, r);
 109         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2", DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2, r);
 110         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6, r);
 111         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS", DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS, r);
 112         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8, r);
 113         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5, r);
 114         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6, r);
 115         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3, r);
 116         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7, r);
 117         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT", DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT, r);
 118         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS", DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS, r);
 119         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V10", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V10, r);
 120         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_RESERVED_PART2", DRSUAPI_SUPPORTED_EXTENSION_RESERVED_PART2, r);
 121         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_RESERVED_PART3", DRSUAPI_SUPPORTED_EXTENSION_RESERVED_PART3, r);
 122         ndr->depth--;
 123 }
 124
 125 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensionsExt(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 126 {
 127         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 128         return NDR_ERR_SUCCESS;
 129 }
 130
 131 static enum ndr_err_code ndr_pull_drsuapi_SupportedExtensionsExt(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 132 {
 133         uint32_t v;
 134         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 135         *r = v;
 136         return NDR_ERR_SUCCESS;
 137 }
 138
 139 _PUBLIC_ void ndr_print_drsuapi_SupportedExtensionsExt(struct ndr_print *ndr, const char *name, uint32_t r)
 140 {
 141         ndr_print_uint32(ndr, name, r);
 142         ndr->depth++;
 143         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADAM", DRSUAPI_SUPPORTED_EXTENSION_ADAM, r);
 144         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_LH_BETA2", DRSUAPI_SUPPORTED_EXTENSION_LH_BETA2, r);
 145         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_RECYCLE_BIN", DRSUAPI_SUPPORTED_EXTENSION_RECYCLE_BIN, r);
 146         ndr->depth--;
 147 }
 148
 149 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo24(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo24 *r)
 150 {
 151         if (ndr_flags & NDR_SCALARS) {
 152                 NDR_CHECK(ndr_push_align(ndr, 4));
 153                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 154                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 156                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 157         }
 158         if (ndr_flags & NDR_BUFFERS) {
 159         }
 160         return NDR_ERR_SUCCESS;
 161 }
 162
 163 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo24(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo24 *r)
 164 {
 165         if (ndr_flags & NDR_SCALARS) {
 166                 NDR_CHECK(ndr_pull_align(ndr, 4));
 167                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 168                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 170                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 171         }
 172         if (ndr_flags & NDR_BUFFERS) {
 173         }
 174         return NDR_ERR_SUCCESS;
 175 }
 176
 177 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo24(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo24 *r)
 178 {
 179         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo24");
 180         ndr->depth++;
 181         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 182         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 183         ndr_print_uint32(ndr, "pid", r->pid);
 184         ndr->depth--;
 185 }
 186
 187 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo28(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo28 *r)
 188 {
 189         if (ndr_flags & NDR_SCALARS) {
 190                 NDR_CHECK(ndr_push_align(ndr, 4));
 191                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 192                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 193                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 194                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 195                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 196         }
 197         if (ndr_flags & NDR_BUFFERS) {
 198         }
 199         return NDR_ERR_SUCCESS;
 200 }
 201
 202 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo28(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo28 *r)
 203 {
 204         if (ndr_flags & NDR_SCALARS) {
 205                 NDR_CHECK(ndr_pull_align(ndr, 4));
 206                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 207                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 208                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 209                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 210                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 211         }
 212         if (ndr_flags & NDR_BUFFERS) {
 213         }
 214         return NDR_ERR_SUCCESS;
 215 }
 216
 217 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo28(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo28 *r)
 218 {
 219         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo28");
 220         ndr->depth++;
 221         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 222         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 223         ndr_print_uint32(ndr, "pid", r->pid);
 224         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 225         ndr->depth--;
 226 }
 227
 228 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo48(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo48 *r)
 229 {
 230         if (ndr_flags & NDR_SCALARS) {
 231                 NDR_CHECK(ndr_push_align(ndr, 4));
 232                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 233                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 235                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 236                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, r->supported_extensions_ext));
 237                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 238                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 239         }
 240         if (ndr_flags & NDR_BUFFERS) {
 241         }
 242         return NDR_ERR_SUCCESS;
 243 }
 244
 245 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo48(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo48 *r)
 246 {
 247         if (ndr_flags & NDR_SCALARS) {
 248                 NDR_CHECK(ndr_pull_align(ndr, 4));
 249                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 250                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 251                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 253                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, &r->supported_extensions_ext));
 254                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 255                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 256         }
 257         if (ndr_flags & NDR_BUFFERS) {
 258         }
 259         return NDR_ERR_SUCCESS;
 260 }
 261
 262 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo48(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo48 *r)
 263 {
 264         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo48");
 265         ndr->depth++;
 266         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 267         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 268         ndr_print_uint32(ndr, "pid", r->pid);
 269         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 270         ndr_print_drsuapi_SupportedExtensionsExt(ndr, "supported_extensions_ext", r->supported_extensions_ext);
 271         ndr_print_GUID(ndr, "config_dn_guid", &r->config_dn_guid);
 272         ndr->depth--;
 273 }
 274
 275 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoFallBack(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoFallBack *r)
 276 {
 277         if (ndr_flags & NDR_SCALARS) {
 278                 NDR_CHECK(ndr_push_align(ndr, 4));
 279                 {
 280                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 281                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 282                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->info));
 283                         ndr->flags = _flags_save_DATA_BLOB;
 284                 }
 285                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 286         }
 287         if (ndr_flags & NDR_BUFFERS) {
 288         }
 289         return NDR_ERR_SUCCESS;
 290 }
 291
 292 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoFallBack(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoFallBack *r)
 293 {
 294         if (ndr_flags & NDR_SCALARS) {
 295                 NDR_CHECK(ndr_pull_align(ndr, 4));
 296                 {
 297                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 298                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 299                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->info));
 300                         ndr->flags = _flags_save_DATA_BLOB;
 301                 }
 302                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 303         }
 304         if (ndr_flags & NDR_BUFFERS) {
 305         }
 306         return NDR_ERR_SUCCESS;
 307 }
 308
 309 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoFallBack(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoFallBack *r)
 310 {
 311         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoFallBack");
 312         ndr->depth++;
 313         ndr_print_DATA_BLOB(ndr, "info", r->info);
 314         ndr->depth--;
 315 }
 316
 317 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsBindInfo *r)
 318 {
 319         if (ndr_flags & NDR_SCALARS) {
 320                 int level = ndr_push_get_switch_value(ndr, r);
 321                 NDR_CHECK(ndr_push_union_align(ndr, 1));
 322                 switch (level) {
 323                         case 24: {
 324                                 {
 325                                         struct ndr_push *_ndr_info24;
 326                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info24, 4, -1));
 327                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 328                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info24, 4, -1));
 329                                 }
 330                         break; }
 331
 332                         case 28: {
 333                                 {
 334                                         struct ndr_push *_ndr_info28;
 335                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info28, 4, -1));
 336                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 337                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info28, 4, -1));
 338                                 }
 339                         break; }
 340
 341                         case 48: {
 342                                 {
 343                                         struct ndr_push *_ndr_info48;
 344                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info48, 4, -1));
 345                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 346                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info48, 4, -1));
 347                                 }
 348                         break; }
 349
 350                         default: {
 351                                 {
 352                                         struct ndr_push *_ndr_FallBack;
 353                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 354                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 355                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 356                                 }
 357                         break; }
 358
 359                 }
 360         }
 361         if (ndr_flags & NDR_BUFFERS) {
 362                 int level = ndr_push_get_switch_value(ndr, r);
 363                 switch (level) {
 364                         case 24:
 365                         break;
 366
 367                         case 28:
 368                         break;
 369
 370                         case 48:
 371                         break;
 372
 373                         default:
 374                         break;
 375
 376                 }
 377         }
 378         return NDR_ERR_SUCCESS;
 379 }
 380
 381 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsBindInfo *r)
 382 {
 383         int level;
 384         level = ndr_pull_get_switch_value(ndr, r);
 385         if (ndr_flags & NDR_SCALARS) {
 386                 NDR_CHECK(ndr_pull_union_align(ndr, 1));
 387                 switch (level) {
 388                         case 24: {
 389                                 {
 390                                         struct ndr_pull *_ndr_info24;
 391                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info24, 4, -1));
 392                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 393                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info24, 4, -1));
 394                                 }
 395                         break; }
 396
 397                         case 28: {
 398                                 {
 399                                         struct ndr_pull *_ndr_info28;
 400                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info28, 4, -1));
 401                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 402                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info28, 4, -1));
 403                                 }
 404                         break; }
 405
 406                         case 48: {
 407                                 {
 408                                         struct ndr_pull *_ndr_info48;
 409                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info48, 4, -1));
 410                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 411                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info48, 4, -1));
 412                                 }
 413                         break; }
 414
 415                         default: {
 416                                 {
 417                                         struct ndr_pull *_ndr_FallBack;
 418                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 419                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 420                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 421                                 }
 422                         break; }
 423
 424                 }
 425         }
 426         if (ndr_flags & NDR_BUFFERS) {
 427                 switch (level) {
 428                         case 24:
 429                         break;
 430
 431                         case 28:
 432                         break;
 433
 434                         case 48:
 435                         break;
 436
 437                         default:
 438                         break;
 439
 440                 }
 441         }
 442         return NDR_ERR_SUCCESS;
 443 }
 444
 445 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsBindInfo *r)
 446 {
 447         int level;
 448         level = ndr_print_get_switch_value(ndr, r);
 449         ndr_print_union(ndr, name, level, "drsuapi_DsBindInfo");
 450         switch (level) {
 451                 case 24:
 452                         ndr_print_drsuapi_DsBindInfo24(ndr, "info24", &r->info24);
 453                 break;
 454
 455                 case 28:
 456                         ndr_print_drsuapi_DsBindInfo28(ndr, "info28", &r->info28);
 457                 break;
 458
 459                 case 48:
 460                         ndr_print_drsuapi_DsBindInfo48(ndr, "info48", &r->info48);
 461                 break;
 462
 463                 default:
 464                         ndr_print_drsuapi_DsBindInfoFallBack(ndr, "FallBack", &r->FallBack);
 465                 break;
 466
 467         }
 468 }
 469
 470 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoCtr *r)
 471 {
 472         if (ndr_flags & NDR_SCALARS) {
 473                 NDR_CHECK(ndr_push_align(ndr, 4));
 474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
 475                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->length));
 476                 NDR_CHECK(ndr_push_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 477                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 478         }
 479         if (ndr_flags & NDR_BUFFERS) {
 480         }
 481         return NDR_ERR_SUCCESS;
 482 }
 483
 484 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoCtr *r)
 485 {
 486         if (ndr_flags & NDR_SCALARS) {
 487                 NDR_CHECK(ndr_pull_align(ndr, 4));
 488                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 489                 if (r->length < 1 || r->length > 10000) {
 490                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 491                 }
 492                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->length));
 493                 NDR_CHECK(ndr_pull_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 494                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 495         }
 496         if (ndr_flags & NDR_BUFFERS) {
 497         }
 498         return NDR_ERR_SUCCESS;
 499 }
 500
 501 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoCtr *r)
 502 {
 503         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoCtr");
 504         ndr->depth++;
 505         ndr_print_uint32(ndr, "length", r->length);
 506         ndr_print_set_switch_value(ndr, &r->info, r->length);
 507         ndr_print_drsuapi_DsBindInfo(ndr, "info", &r->info);
 508         ndr->depth--;
 509 }
 510
 511 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier *r)
 512 {
 513         if (ndr_flags & NDR_SCALARS) {
 514                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, strlen_m(r->dn) + 1));
 515                 NDR_CHECK(ndr_push_align(ndr, 4));
 516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->iconv_convenience, ndr->flags) - 4));
 517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
 518                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
 519                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
 520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
 521                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
 522                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 523         }
 524         if (ndr_flags & NDR_BUFFERS) {
 525                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
 526         }
 527         return NDR_ERR_SUCCESS;
 528 }
 529
 530 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier *r)
 531 {
 532         if (ndr_flags & NDR_SCALARS) {
 533                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dn));
 534                 NDR_CHECK(ndr_pull_align(ndr, 4));
 535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
 536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
 537                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
 538                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
 539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
 540                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, ndr_get_array_size(ndr, &r->dn), sizeof(uint16_t), CH_UTF16));
 541                 if (r->dn) {
 542                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->dn, r->__ndr_size_dn + 1));
 543                 }
 544                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 545         }
 546         if (ndr_flags & NDR_BUFFERS) {
 547                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
 548         }
 549         return NDR_ERR_SUCCESS;
 550 }
 551
 552 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier *r)
 553 {
 554         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier");
 555         ndr->depth++;
 556         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->iconv_convenience, ndr->flags) - 4:r->__ndr_size);
 557         ndr_print_uint32(ndr, "__ndr_size_sid", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_dom_sid28(&r->sid, ndr->flags):r->__ndr_size_sid);
 558         ndr_print_GUID(ndr, "guid", &r->guid);
 559         ndr_print_dom_sid28(ndr, "sid", &r->sid);
 560         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
 561         ndr_print_string(ndr, "dn", r->dn);
 562         ndr->depth--;
 563 }
 564
 565 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier(const struct drsuapi_DsReplicaObjectIdentifier *r, struct smb_iconv_convenience *ic, int flags)
 566 {
 567         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier, ic);
 568 }
 569
 570 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 571 {
 572         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 573         return NDR_ERR_SUCCESS;
 574 }
 575
 576 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 577 {
 578         uint32_t v;
 579         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 580         *r = v;
 581         return NDR_ERR_SUCCESS;
 582 }
 583
 584 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncOptions(struct ndr_print *ndr, const char *name, uint32_t r)
 585 {
 586         ndr_print_uint32(ndr, name, r);
 587         ndr->depth++;
 588         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION, r);
 589         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_WRITEABLE", DRSUAPI_DS_REPLICA_SYNC_WRITEABLE, r);
 590         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PERIODIC", DRSUAPI_DS_REPLICA_SYNC_PERIODIC, r);
 591         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING", DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING, r);
 592         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES", DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES, r);
 593         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL", DRSUAPI_DS_REPLICA_SYNC_FULL, r);
 594         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_URGENT", DRSUAPI_DS_REPLICA_SYNC_URGENT, r);
 595         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD", DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD, r);
 596         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FORCE", DRSUAPI_DS_REPLICA_SYNC_FORCE, r);
 597         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE", DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE, r);
 598         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED", DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED, r);
 599         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_TWO_WAY", DRSUAPI_DS_REPLICA_SYNC_TWO_WAY, r);
 600         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY", DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY, r);
 601         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL", DRSUAPI_DS_REPLICA_SYNC_INITIAL, r);
 602         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION", DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION, r);
 603         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ABANDONED", DRSUAPI_DS_REPLICA_SYNC_ABANDONED, r);
 604         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS, r);
 605         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET", DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET, r);
 606         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_REQUEUE", DRSUAPI_DS_REPLICA_SYNC_REQUEUE, r);
 607         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION", DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION, r);
 608         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA, r);
 609         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_CRITICAL", DRSUAPI_DS_REPLICA_SYNC_CRITICAL, r);
 610         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS, r);
 611         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PREEMPTED", DRSUAPI_DS_REPLICA_SYNC_PREEMPTED, r);
 612         ndr->depth--;
 613 }
 614
 615 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaSyncRequest1 *r)
 616 {
 617         if (ndr_flags & NDR_SCALARS) {
 618                 NDR_CHECK(ndr_push_align(ndr, 5));
 619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
 620                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 621                 {
 622                         uint32_t _flags_save_string = ndr->flags;
 623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 624                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_info));
 625                         ndr->flags = _flags_save_string;
 626                 }
 627                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
 628                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 629         }
 630         if (ndr_flags & NDR_BUFFERS) {
 631                 if (r->naming_context) {
 632                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 633                 }
 634                 {
 635                         uint32_t _flags_save_string = ndr->flags;
 636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 637                         if (r->other_info) {
 638                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->other_info));
 639                         }
 640                         ndr->flags = _flags_save_string;
 641                 }
 642         }
 643         return NDR_ERR_SUCCESS;
 644 }
 645
 646 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaSyncRequest1 *r)
 647 {
 648         uint32_t _ptr_naming_context;
 649         TALLOC_CTX *_mem_save_naming_context_0;
 650         uint32_t _ptr_other_info;
 651         TALLOC_CTX *_mem_save_other_info_0;
 652         if (ndr_flags & NDR_SCALARS) {
 653                 NDR_CHECK(ndr_pull_align(ndr, 5));
 654                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
 655                 if (_ptr_naming_context) {
 656                         NDR_PULL_ALLOC(ndr, r->naming_context);
 657                 } else {
 658                         r->naming_context = NULL;
 659                 }
 660                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 661                 {
 662                         uint32_t _flags_save_string = ndr->flags;
 663                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 664                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_info));
 665                         if (_ptr_other_info) {
 666                                 NDR_PULL_ALLOC(ndr, r->other_info);
 667                         } else {
 668                                 r->other_info = NULL;
 669                         }
 670                         ndr->flags = _flags_save_string;
 671                 }
 672                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
 673                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 674         }
 675         if (ndr_flags & NDR_BUFFERS) {
 676                 if (r->naming_context) {
 677                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
 678                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
 679                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 680                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
 681                 }
 682                 {
 683                         uint32_t _flags_save_string = ndr->flags;
 684                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 685                         if (r->other_info) {
 686                                 _mem_save_other_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 687                                 NDR_PULL_SET_MEM_CTX(ndr, r->other_info, 0);
 688                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->other_info));
 689                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_info_0, 0);
 690                         }
 691                         ndr->flags = _flags_save_string;
 692                 }
 693         }
 694         return NDR_ERR_SUCCESS;
 695 }
 696
 697 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaSyncRequest1 *r)
 698 {
 699         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSyncRequest1");
 700         ndr->depth++;
 701         ndr_print_ptr(ndr, "naming_context", r->naming_context);
 702         ndr->depth++;
 703         if (r->naming_context) {
 704                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
 705         }
 706         ndr->depth--;
 707         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
 708         ndr_print_ptr(ndr, "other_info", r->other_info);
 709         ndr->depth++;
 710         if (r->other_info) {
 711                 ndr_print_string(ndr, "other_info", r->other_info);
 712         }
 713         ndr->depth--;
 714         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
 715         ndr->depth--;
 716 }
 717
 718 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaSyncRequest *r)
 719 {
 720         if (ndr_flags & NDR_SCALARS) {
 721                 int level = ndr_push_get_switch_value(ndr, r);
 722                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
 723                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 724                 switch (level) {
 725                         case 1: {
 726                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 727                         break; }
 728
 729                         default:
 730                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 731                 }
 732         }
 733         if (ndr_flags & NDR_BUFFERS) {
 734                 int level = ndr_push_get_switch_value(ndr, r);
 735                 switch (level) {
 736                         case 1:
 737                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 738                         break;
 739
 740                         default:
 741                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 742                 }
 743         }
 744         return NDR_ERR_SUCCESS;
 745 }
 746
 747 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaSyncRequest *r)
 748 {
 749         int level;
 750         int32_t _level;
 751         level = ndr_pull_get_switch_value(ndr, r);
 752         if (ndr_flags & NDR_SCALARS) {
 753                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
 754                 if (_level != level) {
 755                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 756                 }
 757                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 758                 switch (level) {
 759                         case 1: {
 760                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 761                         break; }
 762
 763                         default:
 764                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 765                 }
 766         }
 767         if (ndr_flags & NDR_BUFFERS) {
 768                 switch (level) {
 769                         case 1:
 770                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 771                         break;
 772
 773                         default:
 774                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 775                 }
 776         }
 777         return NDR_ERR_SUCCESS;
 778 }
 779
 780 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaSyncRequest *r)
 781 {
 782         int level;
 783         level = ndr_print_get_switch_value(ndr, r);
 784         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaSyncRequest");
 785         switch (level) {
 786                 case 1:
 787                         ndr_print_drsuapi_DsReplicaSyncRequest1(ndr, "req1", &r->req1);
 788                 break;
 789
 790                 default:
 791                         ndr_print_bad_level(ndr, name, level);
 792         }
 793 }
 794
 795 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaHighWaterMark(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaHighWaterMark *r)
 796 {
 797         if (ndr_flags & NDR_SCALARS) {
 798                 NDR_CHECK(ndr_push_align(ndr, 8));
 799                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
 800                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->reserved_usn));
 801                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 802                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 803         }
 804         if (ndr_flags & NDR_BUFFERS) {
 805         }
 806         return NDR_ERR_SUCCESS;
 807 }
 808
 809 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaHighWaterMark(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaHighWaterMark *r)
 810 {
 811         if (ndr_flags & NDR_SCALARS) {
 812                 NDR_CHECK(ndr_pull_align(ndr, 8));
 813                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
 814                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->reserved_usn));
 815                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 816                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 817         }
 818         if (ndr_flags & NDR_BUFFERS) {
 819         }
 820         return NDR_ERR_SUCCESS;
 821 }
 822
 823 _PUBLIC_ void ndr_print_drsuapi_DsReplicaHighWaterMark(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaHighWaterMark *r)
 824 {
 825         ndr_print_struct(ndr, name, "drsuapi_DsReplicaHighWaterMark");
 826         ndr->depth++;
 827         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
 828         ndr_print_hyper(ndr, "reserved_usn", r->reserved_usn);
 829         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 830         ndr->depth--;
 831 }
 832
 833 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor *r)
 834 {
 835         if (ndr_flags & NDR_SCALARS) {
 836                 NDR_CHECK(ndr_push_align(ndr, 8));
 837                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 838                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 839                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 840         }
 841         if (ndr_flags & NDR_BUFFERS) {
 842         }
 843         return NDR_ERR_SUCCESS;
 844 }
 845
 846 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor *r)
 847 {
 848         if (ndr_flags & NDR_SCALARS) {
 849                 NDR_CHECK(ndr_pull_align(ndr, 8));
 850                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 851                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 852                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 853         }
 854         if (ndr_flags & NDR_BUFFERS) {
 855         }
 856         return NDR_ERR_SUCCESS;
 857 }
 858
 859 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor *r)
 860 {
 861         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor");
 862         ndr->depth++;
 863         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
 864         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 865         ndr->depth--;
 866 }
 867
 868 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtrEx *r)
 869 {
 870         uint32_t cntr_cursors_0;
 871         if (ndr_flags & NDR_SCALARS) {
 872                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 873                 NDR_CHECK(ndr_push_align(ndr, 8));
 874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
 875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 877                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 878                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 879                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 880                 }
 881                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 882         }
 883         if (ndr_flags & NDR_BUFFERS) {
 884         }
 885         return NDR_ERR_SUCCESS;
 886 }
 887
 888 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtrEx *r)
 889 {
 890         uint32_t cntr_cursors_0;
 891         TALLOC_CTX *_mem_save_cursors_0;
 892         if (ndr_flags & NDR_SCALARS) {
 893                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
 894                 NDR_CHECK(ndr_pull_align(ndr, 8));
 895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 897                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 898                 if (r->count > 0x100000) {
 899                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 900                 }
 901                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 902                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
 903                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
 904                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
 905                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 906                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 907                 }
 908                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
 909                 if (r->cursors) {
 910                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
 911                 }
 912                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 913         }
 914         if (ndr_flags & NDR_BUFFERS) {
 915         }
 916         return NDR_ERR_SUCCESS;
 917 }
 918
 919 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtrEx *r)
 920 {
 921         uint32_t cntr_cursors_0;
 922         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtrEx");
 923         ndr->depth++;
 924         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
 925         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
 926         ndr_print_uint32(ndr, "count", r->count);
 927         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
 928         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
 929         ndr->depth++;
 930         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
 931                 char *idx_0=NULL;
 932                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
 933                         ndr_print_drsuapi_DsReplicaCursor(ndr, "cursors", &r->cursors[cntr_cursors_0]);
 934                         free(idx_0);
 935                 }
 936         }
 937         ndr->depth--;
 938         ndr->depth--;
 939 }
 940
 941 static enum ndr_err_code ndr_push_drsuapi_DsExtendedOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation r)
 942 {
 943         {
 944                 uint32_t _flags_save_ENUM = ndr->flags;
 945                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 946                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 947                 ndr->flags = _flags_save_ENUM;
 948         }
 949         return NDR_ERR_SUCCESS;
 950 }
 951
 952 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation *r)
 953 {
 954         uint32_t v;
 955         {
 956                 uint32_t _flags_save_ENUM = ndr->flags;
 957                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 958                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 959                 *r = v;
 960                 ndr->flags = _flags_save_ENUM;
 961         }
 962         return NDR_ERR_SUCCESS;
 963 }
 964
 965 _PUBLIC_ void ndr_print_drsuapi_DsExtendedOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedOperation r)
 966 {
 967         const char *val = NULL;
 968
 969         {
 970                 uint32_t _flags_save_ENUM = ndr->flags;
 971                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 972                 switch (r) {
 973                         case DRSUAPI_EXOP_NONE: val = "DRSUAPI_EXOP_NONE"; break;
 974                         case DRSUAPI_EXOP_FSMO_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_REQ_ROLE"; break;
 975                         case DRSUAPI_EXOP_FSMO_RID_ALLOC: val = "DRSUAPI_EXOP_FSMO_RID_ALLOC"; break;
 976                         case DRSUAPI_EXOP_FSMO_RID_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_RID_REQ_ROLE"; break;
 977                         case DRSUAPI_EXOP_FSMO_REQ_PDC: val = "DRSUAPI_EXOP_FSMO_REQ_PDC"; break;
 978                         case DRSUAPI_EXOP_FSMO_ABANDON_ROLE: val = "DRSUAPI_EXOP_FSMO_ABANDON_ROLE"; break;
 979                         case DRSUAPI_EXOP_REPL_OBJ: val = "DRSUAPI_EXOP_REPL_OBJ"; break;
 980                         case DRSUAPI_EXOP_REPL_SECRET: val = "DRSUAPI_EXOP_REPL_SECRET"; break;
 981                 }
 982                 ndr_print_enum(ndr, name, "ENUM", val, r);
 983                 ndr->flags = _flags_save_ENUM;
 984         }
 985 }
 986
 987 static enum ndr_err_code ndr_push_drsuapi_DsExtendedError(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedError r)
 988 {
 989         {
 990                 uint32_t _flags_save_ENUM = ndr->flags;
 991                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 992                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 993                 ndr->flags = _flags_save_ENUM;
 994         }
 995         return NDR_ERR_SUCCESS;
 996 }
 997
 998 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedError(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedError *r)
 999 {
1000         uint32_t v;
1001         {
1002                 uint32_t _flags_save_ENUM = ndr->flags;
1003                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1004                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1005                 *r = v;
1006                 ndr->flags = _flags_save_ENUM;
1007         }
1008         return NDR_ERR_SUCCESS;
1009 }
1010
1011 _PUBLIC_ void ndr_print_drsuapi_DsExtendedError(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedError r)
1012 {
1013         const char *val = NULL;
1014
1015         {
1016                 uint32_t _flags_save_ENUM = ndr->flags;
1017                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1018                 switch (r) {
1019                         case DRSUAPI_EXOP_ERR_NONE: val = "DRSUAPI_EXOP_ERR_NONE"; break;
1020                         case DRSUAPI_EXOP_ERR_SUCCESS: val = "DRSUAPI_EXOP_ERR_SUCCESS"; break;
1021                         case DRSUAPI_EXOP_ERR_UNKNOWN_OP: val = "DRSUAPI_EXOP_ERR_UNKNOWN_OP"; break;
1022                         case DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER: val = "DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER"; break;
1023                         case DRSUAPI_EXOP_ERR_UPDATE_ERR: val = "DRSUAPI_EXOP_ERR_UPDATE_ERR"; break;
1024                         case DRSUAPI_EXOP_ERR_EXCEPTION: val = "DRSUAPI_EXOP_ERR_EXCEPTION"; break;
1025                         case DRSUAPI_EXOP_ERR_UNKNOWN_CALLER: val = "DRSUAPI_EXOP_ERR_UNKNOWN_CALLER"; break;
1026                         case DRSUAPI_EXOP_ERR_RID_ALLOC: val = "DRSUAPI_EXOP_ERR_RID_ALLOC"; break;
1027                         case DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED: val = "DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED"; break;
1028                         case DRSUAPI_EXOP_ERR_FMSO_PENDING_OP: val = "DRSUAPI_EXOP_ERR_FMSO_PENDING_OP"; break;
1029                         case DRSUAPI_EXOP_ERR_MISMATCH: val = "DRSUAPI_EXOP_ERR_MISMATCH"; break;
1030                         case DRSUAPI_EXOP_ERR_COULDNT_CONTACT: val = "DRSUAPI_EXOP_ERR_COULDNT_CONTACT"; break;
1031                         case DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES: val = "DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES"; break;
1032                         case DRSUAPI_EXOP_ERR_DIR_ERROR: val = "DRSUAPI_EXOP_ERR_DIR_ERROR"; break;
1033                         case DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS: val = "DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS"; break;
1034                         case DRSUAPI_EXOP_ERR_ACCESS_DENIED: val = "DRSUAPI_EXOP_ERR_ACCESS_DENIED"; break;
1035                         case DRSUAPI_EXOP_ERR_PARAM_ERROR: val = "DRSUAPI_EXOP_ERR_PARAM_ERROR"; break;
1036                 }
1037                 ndr_print_enum(ndr, name, "ENUM", val, r);
1038                 ndr->flags = _flags_save_ENUM;
1039         }
1040 }
1041
1042 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest5(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest5 *r)
1043 {
1044         if (ndr_flags & NDR_SCALARS) {
1045                 NDR_CHECK(ndr_push_align(ndr, 8));
1046                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1047                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1048                 if (r->naming_context == NULL) {
1049                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1050                 }
1051                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1052                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1053                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1054                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
1055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1057                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1058                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1059                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1060         }
1061         if (ndr_flags & NDR_BUFFERS) {
1062                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1063                 if (r->uptodateness_vector) {
1064                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1065                 }
1066         }
1067         return NDR_ERR_SUCCESS;
1068 }
1069
1070 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest5(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest5 *r)
1071 {
1072         uint32_t _ptr_naming_context;
1073         TALLOC_CTX *_mem_save_naming_context_0;
1074         uint32_t _ptr_uptodateness_vector;
1075         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1076         if (ndr_flags & NDR_SCALARS) {
1077                 NDR_CHECK(ndr_pull_align(ndr, 8));
1078                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1079                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1080                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1081                 if (_ptr_naming_context) {
1082                         NDR_PULL_ALLOC(ndr, r->naming_context);
1083                 } else {
1084                         r->naming_context = NULL;
1085                 }
1086                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1087                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1088                 if (_ptr_uptodateness_vector) {
1089                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1090                 } else {
1091                         r->uptodateness_vector = NULL;
1092                 }
1093                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
1094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1095                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1096                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1097                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1098                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1099         }
1100         if (ndr_flags & NDR_BUFFERS) {
1101                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1102                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1103                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1104                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1105                 if (r->uptodateness_vector) {
1106                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1107                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1108                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1109                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1110                 }
1111         }
1112         return NDR_ERR_SUCCESS;
1113 }
1114
1115 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest5(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest5 *r)
1116 {
1117         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest5");
1118         ndr->depth++;
1119         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1120         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1121         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1122         ndr->depth++;
1123         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1124         ndr->depth--;
1125         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1126         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1127         ndr->depth++;
1128         if (r->uptodateness_vector) {
1129                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1130         }
1131         ndr->depth--;
1132         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
1133         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1134         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1135         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1136         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1137         ndr->depth--;
1138 }
1139
1140 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOID(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOID *r)
1141 {
1142         if (ndr_flags & NDR_SCALARS) {
1143                 NDR_CHECK(ndr_push_align(ndr, 5));
1144                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
1145                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary_oid));
1146                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1147         }
1148         if (ndr_flags & NDR_BUFFERS) {
1149                 if (r->binary_oid) {
1150                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
1151                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->binary_oid, r->length));
1152                 }
1153         }
1154         return NDR_ERR_SUCCESS;
1155 }
1156
1157 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOID(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOID *r)
1158 {
1159         uint32_t _ptr_binary_oid;
1160         TALLOC_CTX *_mem_save_binary_oid_0;
1161         if (ndr_flags & NDR_SCALARS) {
1162                 NDR_CHECK(ndr_pull_align(ndr, 5));
1163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
1164                 if (r->length > 10000) {
1165                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1166                 }
1167                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_oid));
1168                 if (_ptr_binary_oid) {
1169                         NDR_PULL_ALLOC(ndr, r->binary_oid);
1170                 } else {
1171                         r->binary_oid = NULL;
1172                 }
1173                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1174         }
1175         if (ndr_flags & NDR_BUFFERS) {
1176                 if (r->binary_oid) {
1177                         _mem_save_binary_oid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1178                         NDR_PULL_SET_MEM_CTX(ndr, r->binary_oid, 0);
1179                         NDR_CHECK(ndr_pull_array_size(ndr, &r->binary_oid));
1180                         NDR_PULL_ALLOC_N(ndr, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid));
1181                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid)));
1182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_oid_0, 0);
1183                 }
1184                 if (r->binary_oid) {
1185                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->binary_oid, r->length));
1186                 }
1187         }
1188         return NDR_ERR_SUCCESS;
1189 }
1190
1191 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping *r)
1192 {
1193         if (ndr_flags & NDR_SCALARS) {
1194                 NDR_CHECK(ndr_push_align(ndr, 5));
1195                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id_prefix));
1196                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1197                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1198         }
1199         if (ndr_flags & NDR_BUFFERS) {
1200                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1201         }
1202         return NDR_ERR_SUCCESS;
1203 }
1204
1205 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping *r)
1206 {
1207         if (ndr_flags & NDR_SCALARS) {
1208                 NDR_CHECK(ndr_pull_align(ndr, 5));
1209                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id_prefix));
1210                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1211                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1212         }
1213         if (ndr_flags & NDR_BUFFERS) {
1214                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1215         }
1216         return NDR_ERR_SUCCESS;
1217 }
1218
1219 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping *r)
1220 {
1221         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping");
1222         ndr->depth++;
1223         ndr_print_uint32(ndr, "id_prefix", r->id_prefix);
1224         ndr_print_drsuapi_DsReplicaOID(ndr, "oid", &r->oid);
1225         ndr->depth--;
1226 }
1227
1228 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1229 {
1230         uint32_t cntr_mappings_1;
1231         if (ndr_flags & NDR_SCALARS) {
1232                 NDR_CHECK(ndr_push_align(ndr, 5));
1233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
1234                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mappings));
1235                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1236         }
1237         if (ndr_flags & NDR_BUFFERS) {
1238                 if (r->mappings) {
1239                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_mappings));
1240                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1241                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1242                         }
1243                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1244                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1245                         }
1246                 }
1247         }
1248         return NDR_ERR_SUCCESS;
1249 }
1250
1251 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1252 {
1253         uint32_t _ptr_mappings;
1254         uint32_t cntr_mappings_1;
1255         TALLOC_CTX *_mem_save_mappings_0;
1256         TALLOC_CTX *_mem_save_mappings_1;
1257         if (ndr_flags & NDR_SCALARS) {
1258                 NDR_CHECK(ndr_pull_align(ndr, 5));
1259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mappings));
1260                 if (r->num_mappings > 0x100000) {
1261                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1262                 }
1263                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mappings));
1264                 if (_ptr_mappings) {
1265                         NDR_PULL_ALLOC(ndr, r->mappings);
1266                 } else {
1267                         r->mappings = NULL;
1268                 }
1269                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1270         }
1271         if (ndr_flags & NDR_BUFFERS) {
1272                 if (r->mappings) {
1273                         _mem_save_mappings_0 = NDR_PULL_GET_MEM_CTX(ndr);
1274                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1275                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mappings));
1276                         NDR_PULL_ALLOC_N(ndr, r->mappings, ndr_get_array_size(ndr, &r->mappings));
1277                         _mem_save_mappings_1 = NDR_PULL_GET_MEM_CTX(ndr);
1278                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1279                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1280                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1281                         }
1282                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1283                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1284                         }
1285                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_1, 0);
1286                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_0, 0);
1287                 }
1288                 if (r->mappings) {
1289                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->mappings, r->num_mappings));
1290                 }
1291         }
1292         return NDR_ERR_SUCCESS;
1293 }
1294
1295 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1296 {
1297         uint32_t cntr_mappings_1;
1298         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping_Ctr");
1299         ndr->depth++;
1300         ndr_print_uint32(ndr, "num_mappings", r->num_mappings);
1301         ndr_print_ptr(ndr, "mappings", r->mappings);
1302         ndr->depth++;
1303         if (r->mappings) {
1304                 ndr->print(ndr, "%s: ARRAY(%d)", "mappings", (int)r->num_mappings);
1305                 ndr->depth++;
1306                 for (cntr_mappings_1=0;cntr_mappings_1<r->num_mappings;cntr_mappings_1++) {
1307                         char *idx_1=NULL;
1308                         if (asprintf(&idx_1, "[%d]", cntr_mappings_1) != -1) {
1309                                 ndr_print_drsuapi_DsReplicaOIDMapping(ndr, "mappings", &r->mappings[cntr_mappings_1]);
1310                                 free(idx_1);
1311                         }
1312                 }
1313                 ndr->depth--;
1314         }
1315         ndr->depth--;
1316         ndr->depth--;
1317 }
1318
1319 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAttributeId(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsAttributeId r)
1320 {
1321         {
1322                 uint32_t _flags_save_ENUM = ndr->flags;
1323                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1324                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1325                 ndr->flags = _flags_save_ENUM;
1326         }
1327         return NDR_ERR_SUCCESS;
1328 }
1329
1330 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAttributeId(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsAttributeId *r)
1331 {
1332         uint32_t v;
1333         {
1334                 uint32_t _flags_save_ENUM = ndr->flags;
1335                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1336                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1337                 *r = v;
1338                 ndr->flags = _flags_save_ENUM;
1339         }
1340         return NDR_ERR_SUCCESS;
1341 }
1342
1343 _PUBLIC_ void ndr_print_drsuapi_DsAttributeId(struct ndr_print *ndr, const char *name, enum drsuapi_DsAttributeId r)
1344 {
1345         const char *val = NULL;
1346
1347         {
1348                 uint32_t _flags_save_ENUM = ndr->flags;
1349                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1350                 switch (r) {
1351                         case DRSUAPI_ATTRIBUTE_objectClass: val = "DRSUAPI_ATTRIBUTE_objectClass"; break;
1352                         case DRSUAPI_ATTRIBUTE_cn: val = "DRSUAPI_ATTRIBUTE_cn"; break;
1353                         case DRSUAPI_ATTRIBUTE_description: val = "DRSUAPI_ATTRIBUTE_description"; break;
1354                         case DRSUAPI_ATTRIBUTE_member: val = "DRSUAPI_ATTRIBUTE_member"; break;
1355                         case DRSUAPI_ATTRIBUTE_instanceType: val = "DRSUAPI_ATTRIBUTE_instanceType"; break;
1356                         case DRSUAPI_ATTRIBUTE_whenCreated: val = "DRSUAPI_ATTRIBUTE_whenCreated"; break;
1357                         case DRSUAPI_ATTRIBUTE_possSuperiors: val = "DRSUAPI_ATTRIBUTE_possSuperiors"; break;
1358                         case DRSUAPI_ATTRIBUTE_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_hasMasterNCs"; break;
1359                         case DRSUAPI_ATTRIBUTE_subClassOf: val = "DRSUAPI_ATTRIBUTE_subClassOf"; break;
1360                         case DRSUAPI_ATTRIBUTE_governsID: val = "DRSUAPI_ATTRIBUTE_governsID"; break;
1361                         case DRSUAPI_ATTRIBUTE_mustContain: val = "DRSUAPI_ATTRIBUTE_mustContain"; break;
1362                         case DRSUAPI_ATTRIBUTE_mayContain: val = "DRSUAPI_ATTRIBUTE_mayContain"; break;
1363                         case DRSUAPI_ATTRIBUTE_rDNAttId: val = "DRSUAPI_ATTRIBUTE_rDNAttId"; break;
1364                         case DRSUAPI_ATTRIBUTE_attributeID: val = "DRSUAPI_ATTRIBUTE_attributeID"; break;
1365                         case DRSUAPI_ATTRIBUTE_attributeSyntax: val = "DRSUAPI_ATTRIBUTE_attributeSyntax"; break;
1366                         case DRSUAPI_ATTRIBUTE_isSingleValued: val = "DRSUAPI_ATTRIBUTE_isSingleValued"; break;
1367                         case DRSUAPI_ATTRIBUTE_rangeLower: val = "DRSUAPI_ATTRIBUTE_rangeLower"; break;
1368                         case DRSUAPI_ATTRIBUTE_rangeUpper: val = "DRSUAPI_ATTRIBUTE_rangeUpper"; break;
1369                         case DRSUAPI_ATTRIBUTE_dMDLocation: val = "DRSUAPI_ATTRIBUTE_dMDLocation"; break;
1370                         case DRSUAPI_ATTRIBUTE_objectVersion: val = "DRSUAPI_ATTRIBUTE_objectVersion"; break;
1371                         case DRSUAPI_ATTRIBUTE_invocationId: val = "DRSUAPI_ATTRIBUTE_invocationId"; break;
1372                         case DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly: val = "DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly"; break;
1373                         case DRSUAPI_ATTRIBUTE_adminDisplayName: val = "DRSUAPI_ATTRIBUTE_adminDisplayName"; break;
1374                         case DRSUAPI_ATTRIBUTE_adminDescription: val = "DRSUAPI_ATTRIBUTE_adminDescription"; break;
1375                         case DRSUAPI_ATTRIBUTE_oMSyntax: val = "DRSUAPI_ATTRIBUTE_oMSyntax"; break;
1376                         case DRSUAPI_ATTRIBUTE_ntSecurityDescriptor: val = "DRSUAPI_ATTRIBUTE_ntSecurityDescriptor"; break;
1377                         case DRSUAPI_ATTRIBUTE_searchFlags: val = "DRSUAPI_ATTRIBUTE_searchFlags"; break;
1378                         case DRSUAPI_ATTRIBUTE_auxiliaryClass: val = "DRSUAPI_ATTRIBUTE_auxiliaryClass"; break;
1379                         case DRSUAPI_ATTRIBUTE_lDAPDisplayName: val = "DRSUAPI_ATTRIBUTE_lDAPDisplayName"; break;
1380                         case DRSUAPI_ATTRIBUTE_name: val = "DRSUAPI_ATTRIBUTE_name"; break;
1381                         case DRSUAPI_ATTRIBUTE_userAccountControl: val = "DRSUAPI_ATTRIBUTE_userAccountControl"; break;
1382                         case DRSUAPI_ATTRIBUTE_currentValue: val = "DRSUAPI_ATTRIBUTE_currentValue"; break;
1383                         case DRSUAPI_ATTRIBUTE_homeDirectory: val = "DRSUAPI_ATTRIBUTE_homeDirectory"; break;
1384                         case DRSUAPI_ATTRIBUTE_homeDrive: val = "DRSUAPI_ATTRIBUTE_homeDrive"; break;
1385                         case DRSUAPI_ATTRIBUTE_scriptPath: val = "DRSUAPI_ATTRIBUTE_scriptPath"; break;
1386                         case DRSUAPI_ATTRIBUTE_profilePath: val = "DRSUAPI_ATTRIBUTE_profilePath"; break;
1387                         case DRSUAPI_ATTRIBUTE_objectSid: val = "DRSUAPI_ATTRIBUTE_objectSid"; break;
1388                         case DRSUAPI_ATTRIBUTE_schemaIDGUID: val = "DRSUAPI_ATTRIBUTE_schemaIDGUID"; break;
1389                         case DRSUAPI_ATTRIBUTE_dBCSPwd: val = "DRSUAPI_ATTRIBUTE_dBCSPwd"; break;
1390                         case DRSUAPI_ATTRIBUTE_logonHours: val = "DRSUAPI_ATTRIBUTE_logonHours"; break;
1391                         case DRSUAPI_ATTRIBUTE_userWorkstations: val = "DRSUAPI_ATTRIBUTE_userWorkstations"; break;
1392                         case DRSUAPI_ATTRIBUTE_unicodePwd: val = "DRSUAPI_ATTRIBUTE_unicodePwd"; break;
1393                         case DRSUAPI_ATTRIBUTE_ntPwdHistory: val = "DRSUAPI_ATTRIBUTE_ntPwdHistory"; break;
1394                         case DRSUAPI_ATTRIBUTE_priorValue: val = "DRSUAPI_ATTRIBUTE_priorValue"; break;
1395                         case DRSUAPI_ATTRIBUTE_supplementalCredentials: val = "DRSUAPI_ATTRIBUTE_supplementalCredentials"; break;
1396                         case DRSUAPI_ATTRIBUTE_trustAuthIncoming: val = "DRSUAPI_ATTRIBUTE_trustAuthIncoming"; break;
1397                         case DRSUAPI_ATTRIBUTE_trustAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_trustAuthOutgoing"; break;
1398                         case DRSUAPI_ATTRIBUTE_lmPwdHistory: val = "DRSUAPI_ATTRIBUTE_lmPwdHistory"; break;
1399                         case DRSUAPI_ATTRIBUTE_systemPossSuperiors: val = "DRSUAPI_ATTRIBUTE_systemPossSuperiors"; break;
1400                         case DRSUAPI_ATTRIBUTE_systemMayContain: val = "DRSUAPI_ATTRIBUTE_systemMayContain"; break;
1401                         case DRSUAPI_ATTRIBUTE_systemMustContain: val = "DRSUAPI_ATTRIBUTE_systemMustContain"; break;
1402                         case DRSUAPI_ATTRIBUTE_systemAuxiliaryClass: val = "DRSUAPI_ATTRIBUTE_systemAuxiliaryClass"; break;
1403                         case DRSUAPI_ATTRIBUTE_sAMAccountName: val = "DRSUAPI_ATTRIBUTE_sAMAccountName"; break;
1404                         case DRSUAPI_ATTRIBUTE_sAMAccountType: val = "DRSUAPI_ATTRIBUTE_sAMAccountType"; break;
1405                         case DRSUAPI_ATTRIBUTE_options: val = "DRSUAPI_ATTRIBUTE_options"; break;
1406                         case DRSUAPI_ATTRIBUTE_fSMORoleOwner: val = "DRSUAPI_ATTRIBUTE_fSMORoleOwner"; break;
1407                         case DRSUAPI_ATTRIBUTE_systemFlags: val = "DRSUAPI_ATTRIBUTE_systemFlags"; break;
1408                         case DRSUAPI_ATTRIBUTE_serverReference: val = "DRSUAPI_ATTRIBUTE_serverReference"; break;
1409                         case DRSUAPI_ATTRIBUTE_serverReferenceBL: val = "DRSUAPI_ATTRIBUTE_serverReferenceBL"; break;
1410                         case DRSUAPI_ATTRIBUTE_initialAuthIncoming: val = "DRSUAPI_ATTRIBUTE_initialAuthIncoming"; break;
1411                         case DRSUAPI_ATTRIBUTE_initialAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_initialAuthOutgoing"; break;
1412                         case DRSUAPI_ATTRIBUTE_wellKnownObjects: val = "DRSUAPI_ATTRIBUTE_wellKnownObjects"; break;
1413                         case DRSUAPI_ATTRIBUTE_dNSHostName: val = "DRSUAPI_ATTRIBUTE_dNSHostName"; break;
1414                         case DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet: val = "DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet"; break;
1415                         case DRSUAPI_ATTRIBUTE_userPrincipalName: val = "DRSUAPI_ATTRIBUTE_userPrincipalName"; break;
1416                         case DRSUAPI_ATTRIBUTE_groupType: val = "DRSUAPI_ATTRIBUTE_groupType"; break;
1417                         case DRSUAPI_ATTRIBUTE_servicePrincipalName: val = "DRSUAPI_ATTRIBUTE_servicePrincipalName"; break;
1418                         case DRSUAPI_ATTRIBUTE_objectCategory: val = "DRSUAPI_ATTRIBUTE_objectCategory"; break;
1419                         case DRSUAPI_ATTRIBUTE_gPLink: val = "DRSUAPI_ATTRIBUTE_gPLink"; break;
1420                         case DRSUAPI_ATTRIBUTE_transportAddressAttribute: val = "DRSUAPI_ATTRIBUTE_transportAddressAttribute"; break;
1421                         case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version: val = "DRSUAPI_ATTRIBUTE_msDS_Behavior_Version"; break;
1422                         case DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber: val = "DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber"; break;
1423                         case DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs: val = "DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs"; break;
1424                         case DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs"; break;
1425                         case DRSUAPI_ATTRIBUTE_NONE: val = "DRSUAPI_ATTRIBUTE_NONE"; break;
1426                 }
1427                 ndr_print_enum(ndr, name, "ENUM", val, r);
1428                 ndr->flags = _flags_save_ENUM;
1429         }
1430 }
1431
1432 static enum ndr_err_code ndr_push_drsuapi_DsPartialAttributeSet(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsPartialAttributeSet *r)
1433 {
1434         uint32_t cntr_attids_0;
1435         if (ndr_flags & NDR_SCALARS) {
1436                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attids));
1437                 NDR_CHECK(ndr_push_align(ndr, 4));
1438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
1439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
1441                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1442                         NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attids[cntr_attids_0]));
1443                 }
1444                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1445         }
1446         if (ndr_flags & NDR_BUFFERS) {
1447         }
1448         return NDR_ERR_SUCCESS;
1449 }
1450
1451 static enum ndr_err_code ndr_pull_drsuapi_DsPartialAttributeSet(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsPartialAttributeSet *r)
1452 {
1453         uint32_t cntr_attids_0;
1454         TALLOC_CTX *_mem_save_attids_0;
1455         if (ndr_flags & NDR_SCALARS) {
1456                 NDR_CHECK(ndr_pull_array_size(ndr, &r->attids));
1457                 NDR_CHECK(ndr_pull_align(ndr, 4));
1458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1459                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attids));
1461                 if (r->num_attids < 1 || r->num_attids > 0x100000) {
1462                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1463                 }
1464                 NDR_PULL_ALLOC_N(ndr, r->attids, ndr_get_array_size(ndr, &r->attids));
1465                 _mem_save_attids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1466                 NDR_PULL_SET_MEM_CTX(ndr, r->attids, 0);
1467                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1468                         NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attids[cntr_attids_0]));
1469                 }
1470                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attids_0, 0);
1471                 if (r->attids) {
1472                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attids, r->num_attids));
1473                 }
1474                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1475         }
1476         if (ndr_flags & NDR_BUFFERS) {
1477         }
1478         return NDR_ERR_SUCCESS;
1479 }
1480
1481 _PUBLIC_ void ndr_print_drsuapi_DsPartialAttributeSet(struct ndr_print *ndr, const char *name, const struct drsuapi_DsPartialAttributeSet *r)
1482 {
1483         uint32_t cntr_attids_0;
1484         ndr_print_struct(ndr, name, "drsuapi_DsPartialAttributeSet");
1485         ndr->depth++;
1486         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
1487         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1488         ndr_print_uint32(ndr, "num_attids", r->num_attids);
1489         ndr->print(ndr, "%s: ARRAY(%d)", "attids", (int)r->num_attids);
1490         ndr->depth++;
1491         for (cntr_attids_0=0;cntr_attids_0<r->num_attids;cntr_attids_0++) {
1492                 char *idx_0=NULL;
1493                 if (asprintf(&idx_0, "[%d]", cntr_attids_0) != -1) {
1494                         ndr_print_drsuapi_DsAttributeId(ndr, "attids", r->attids[cntr_attids_0]);
1495                         free(idx_0);
1496                 }
1497         }
1498         ndr->depth--;
1499         ndr->depth--;
1500 }
1501
1502 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest8(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest8 *r)
1503 {
1504         if (ndr_flags & NDR_SCALARS) {
1505                 NDR_CHECK(ndr_push_align(ndr, 8));
1506                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1507                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1508                 if (r->naming_context == NULL) {
1509                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1510                 }
1511                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1512                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1513                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1514                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
1515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1517                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1518                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1519                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1520                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1521                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1522                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1523         }
1524         if (ndr_flags & NDR_BUFFERS) {
1525                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1526                 if (r->uptodateness_vector) {
1527                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1528                 }
1529                 if (r->partial_attribute_set) {
1530                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1531                 }
1532                 if (r->partial_attribute_set_ex) {
1533                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1534                 }
1535                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1536         }
1537         return NDR_ERR_SUCCESS;
1538 }
1539
1540 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest8(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest8 *r)
1541 {
1542         uint32_t _ptr_naming_context;
1543         TALLOC_CTX *_mem_save_naming_context_0;
1544         uint32_t _ptr_uptodateness_vector;
1545         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1546         uint32_t _ptr_partial_attribute_set;
1547         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1548         uint32_t _ptr_partial_attribute_set_ex;
1549         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1550         if (ndr_flags & NDR_SCALARS) {
1551                 NDR_CHECK(ndr_pull_align(ndr, 8));
1552                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1553                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1554                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1555                 if (_ptr_naming_context) {
1556                         NDR_PULL_ALLOC(ndr, r->naming_context);
1557                 } else {
1558                         r->naming_context = NULL;
1559                 }
1560                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1561                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1562                 if (_ptr_uptodateness_vector) {
1563                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1564                 } else {
1565                         r->uptodateness_vector = NULL;
1566                 }
1567                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
1568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1569                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1570                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1571                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1573                 if (_ptr_partial_attribute_set) {
1574                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1575                 } else {
1576                         r->partial_attribute_set = NULL;
1577                 }
1578                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1579                 if (_ptr_partial_attribute_set_ex) {
1580                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1581                 } else {
1582                         r->partial_attribute_set_ex = NULL;
1583                 }
1584                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1585                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1586         }
1587         if (ndr_flags & NDR_BUFFERS) {
1588                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1589                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1590                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1591                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1592                 if (r->uptodateness_vector) {
1593                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1594                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1595                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1596                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1597                 }
1598                 if (r->partial_attribute_set) {
1599                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1600                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1601                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1602                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1603                 }
1604                 if (r->partial_attribute_set_ex) {
1605                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1606                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1607                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1608                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1609                 }
1610                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1611         }
1612         return NDR_ERR_SUCCESS;
1613 }
1614
1615 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest8(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest8 *r)
1616 {
1617         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest8");
1618         ndr->depth++;
1619         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1620         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1621         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1622         ndr->depth++;
1623         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1624         ndr->depth--;
1625         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1626         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1627         ndr->depth++;
1628         if (r->uptodateness_vector) {
1629                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1630         }
1631         ndr->depth--;
1632         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
1633         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1634         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1635         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1636         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1637         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1638         ndr->depth++;
1639         if (r->partial_attribute_set) {
1640                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1641         }
1642         ndr->depth--;
1643         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1644         ndr->depth++;
1645         if (r->partial_attribute_set_ex) {
1646                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1647         }
1648         ndr->depth--;
1649         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1650         ndr->depth--;
1651 }
1652
1653 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest10(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest10 *r)
1654 {
1655         if (ndr_flags & NDR_SCALARS) {
1656                 NDR_CHECK(ndr_push_align(ndr, 8));
1657                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1658                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1659                 if (r->naming_context == NULL) {
1660                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1661                 }
1662                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1663                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1664                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1665                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
1666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1667                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1668                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1669                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1670                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1671                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1672                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_flags));
1674                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1675         }
1676         if (ndr_flags & NDR_BUFFERS) {
1677                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1678                 if (r->uptodateness_vector) {
1679                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1680                 }
1681                 if (r->partial_attribute_set) {
1682                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1683                 }
1684                 if (r->partial_attribute_set_ex) {
1685                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1686                 }
1687                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1688         }
1689         return NDR_ERR_SUCCESS;
1690 }
1691
1692 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest10(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest10 *r)
1693 {
1694         uint32_t _ptr_naming_context;
1695         TALLOC_CTX *_mem_save_naming_context_0;
1696         uint32_t _ptr_uptodateness_vector;
1697         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1698         uint32_t _ptr_partial_attribute_set;
1699         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1700         uint32_t _ptr_partial_attribute_set_ex;
1701         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1702         if (ndr_flags & NDR_SCALARS) {
1703                 NDR_CHECK(ndr_pull_align(ndr, 8));
1704                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1705                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1706                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1707                 if (_ptr_naming_context) {
1708                         NDR_PULL_ALLOC(ndr, r->naming_context);
1709                 } else {
1710                         r->naming_context = NULL;
1711                 }
1712                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1713                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1714                 if (_ptr_uptodateness_vector) {
1715                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1716                 } else {
1717                         r->uptodateness_vector = NULL;
1718                 }
1719                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
1720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1722                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1723                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1724                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1725                 if (_ptr_partial_attribute_set) {
1726                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1727                 } else {
1728                         r->partial_attribute_set = NULL;
1729                 }
1730                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1731                 if (_ptr_partial_attribute_set_ex) {
1732                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1733                 } else {
1734                         r->partial_attribute_set_ex = NULL;
1735                 }
1736                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1737                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_flags));
1738                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1739         }
1740         if (ndr_flags & NDR_BUFFERS) {
1741                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1742                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1743                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1744                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1745                 if (r->uptodateness_vector) {
1746                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1747                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1748                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1749                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1750                 }
1751                 if (r->partial_attribute_set) {
1752                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1753                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1754                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1755                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1756                 }
1757                 if (r->partial_attribute_set_ex) {
1758                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1759                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1760                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1761                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1762                 }
1763                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1764         }
1765         return NDR_ERR_SUCCESS;
1766 }
1767
1768 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest10(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest10 *r)
1769 {
1770         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest10");
1771         ndr->depth++;
1772         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1773         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1774         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1775         ndr->depth++;
1776         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1777         ndr->depth--;
1778         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1779         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1780         ndr->depth++;
1781         if (r->uptodateness_vector) {
1782                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1783         }
1784         ndr->depth--;
1785         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
1786         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1787         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1788         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1789         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1790         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1791         ndr->depth++;
1792         if (r->partial_attribute_set) {
1793                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1794         }
1795         ndr->depth--;
1796         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1797         ndr->depth++;
1798         if (r->partial_attribute_set_ex) {
1799                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1800         }
1801         ndr->depth--;
1802         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1803         ndr_print_uint32(ndr, "more_flags", r->more_flags);
1804         ndr->depth--;
1805 }
1806
1807 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesRequest *r)
1808 {
1809         if (ndr_flags & NDR_SCALARS) {
1810                 int level = ndr_push_get_switch_value(ndr, r);
1811                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
1812                 NDR_CHECK(ndr_push_union_align(ndr, 8));
1813                 switch (level) {
1814                         case 5: {
1815                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1816                         break; }
1817
1818                         case 8: {
1819                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1820                         break; }
1821
1822                         case 10: {
1823                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1824                         break; }
1825
1826                         default:
1827                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1828                 }
1829         }
1830         if (ndr_flags & NDR_BUFFERS) {
1831                 int level = ndr_push_get_switch_value(ndr, r);
1832                 switch (level) {
1833                         case 5:
1834                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1835                         break;
1836
1837                         case 8:
1838                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1839                         break;
1840
1841                         case 10:
1842                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1843                         break;
1844
1845                         default:
1846                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1847                 }
1848         }
1849         return NDR_ERR_SUCCESS;
1850 }
1851
1852 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesRequest *r)
1853 {
1854         int level;
1855         int32_t _level;
1856         level = ndr_pull_get_switch_value(ndr, r);
1857         if (ndr_flags & NDR_SCALARS) {
1858                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
1859                 if (_level != level) {
1860                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1861                 }
1862                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
1863                 switch (level) {
1864                         case 5: {
1865                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1866                         break; }
1867
1868                         case 8: {
1869                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1870                         break; }
1871
1872                         case 10: {
1873                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1874                         break; }
1875
1876                         default:
1877                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1878                 }
1879         }
1880         if (ndr_flags & NDR_BUFFERS) {
1881                 switch (level) {
1882                         case 5:
1883                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1884                         break;
1885
1886                         case 8:
1887                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1888                         break;
1889
1890                         case 10:
1891                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1892                         break;
1893
1894                         default:
1895                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1896                 }
1897         }
1898         return NDR_ERR_SUCCESS;
1899 }
1900
1901 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesRequest *r)
1902 {
1903         int level;
1904         level = ndr_print_get_switch_value(ndr, r);
1905         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesRequest");
1906         switch (level) {
1907                 case 5:
1908                         ndr_print_drsuapi_DsGetNCChangesRequest5(ndr, "req5", &r->req5);
1909                 break;
1910
1911                 case 8:
1912                         ndr_print_drsuapi_DsGetNCChangesRequest8(ndr, "req8", &r->req8);
1913                 break;
1914
1915                 case 10:
1916                         ndr_print_drsuapi_DsGetNCChangesRequest10(ndr, "req10", &r->req10);
1917                 break;
1918
1919                 default:
1920                         ndr_print_bad_level(ndr, name, level);
1921         }
1922 }
1923
1924 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2 *r)
1925 {
1926         if (ndr_flags & NDR_SCALARS) {
1927                 NDR_CHECK(ndr_push_align(ndr, 8));
1928                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1929                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
1930                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
1931                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1932         }
1933         if (ndr_flags & NDR_BUFFERS) {
1934         }
1935         return NDR_ERR_SUCCESS;
1936 }
1937
1938 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2 *r)
1939 {
1940         if (ndr_flags & NDR_SCALARS) {
1941                 NDR_CHECK(ndr_pull_align(ndr, 8));
1942                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1943                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
1944                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
1945                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1946         }
1947         if (ndr_flags & NDR_BUFFERS) {
1948         }
1949         return NDR_ERR_SUCCESS;
1950 }
1951
1952 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2 *r)
1953 {
1954         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2");
1955         ndr->depth++;
1956         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1957         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
1958         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
1959         ndr->depth--;
1960 }
1961
1962 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1963 {
1964         uint32_t cntr_cursors_0;
1965         if (ndr_flags & NDR_SCALARS) {
1966                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1967                 NDR_CHECK(ndr_push_align(ndr, 8));
1968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
1969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1972                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1973                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1974                 }
1975                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1976         }
1977         if (ndr_flags & NDR_BUFFERS) {
1978         }
1979         return NDR_ERR_SUCCESS;
1980 }
1981
1982 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2CtrEx *r)
1983 {
1984         uint32_t cntr_cursors_0;
1985         TALLOC_CTX *_mem_save_cursors_0;
1986         if (ndr_flags & NDR_SCALARS) {
1987                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
1988                 NDR_CHECK(ndr_pull_align(ndr, 8));
1989                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1991                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1992                 if (r->count > 0x100000) {
1993                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1994                 }
1995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1996                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
1997                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
1998                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
1999                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
2000                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
2001                 }
2002                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
2003                 if (r->cursors) {
2004                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
2005                 }
2006                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2007         }
2008         if (ndr_flags & NDR_BUFFERS) {
2009         }
2010         return NDR_ERR_SUCCESS;
2011 }
2012
2013 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2CtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2CtrEx *r)
2014 {
2015         uint32_t cntr_cursors_0;
2016         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2CtrEx");
2017         ndr->depth++;
2018         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
2019         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
2020         ndr_print_uint32(ndr, "count", r->count);
2021         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
2022         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
2023         ndr->depth++;
2024         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
2025                 char *idx_0=NULL;
2026                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
2027                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
2028                         free(idx_0);
2029                 }
2030         }
2031         ndr->depth--;
2032         ndr->depth--;
2033 }
2034
2035 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValue(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValue *r)
2036 {
2037         if (ndr_flags & NDR_SCALARS) {
2038                 NDR_CHECK(ndr_push_align(ndr, 5));
2039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->blob, 0)));
2040                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->blob));
2041                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2042         }
2043         if (ndr_flags & NDR_BUFFERS) {
2044                 if (r->blob) {
2045                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->blob));
2046                 }
2047         }
2048         return NDR_ERR_SUCCESS;
2049 }
2050
2051 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValue *r)
2052 {
2053         uint32_t _ptr_blob;
2054         TALLOC_CTX *_mem_save_blob_0;
2055         if (ndr_flags & NDR_SCALARS) {
2056                 NDR_CHECK(ndr_pull_align(ndr, 5));
2057                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2058                 if (r->__ndr_size > 10485760) {
2059                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2060                 }
2061                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_blob));
2062                 if (_ptr_blob) {
2063                         NDR_PULL_ALLOC(ndr, r->blob);
2064                 } else {
2065                         r->blob = NULL;
2066                 }
2067                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2068         }
2069         if (ndr_flags & NDR_BUFFERS) {
2070                 if (r->blob) {
2071                         _mem_save_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
2072                         NDR_PULL_SET_MEM_CTX(ndr, r->blob, 0);
2073                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->blob));
2074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_blob_0, 0);
2075                 }
2076         }
2077         return NDR_ERR_SUCCESS;
2078 }
2079
2080 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValue(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValue *r)
2081 {
2082         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
2083         ndr->depth++;
2084         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_DATA_BLOB(0, r->blob, 0):r->__ndr_size);
2085         ndr_print_ptr(ndr, "blob", r->blob);
2086         ndr->depth++;
2087         if (r->blob) {
2088                 ndr_print_DATA_BLOB(ndr, "blob", *r->blob);
2089         }
2090         ndr->depth--;
2091         ndr->depth--;
2092 }
2093
2094 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValueCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValueCtr *r)
2095 {
2096         uint32_t cntr_values_1;
2097         if (ndr_flags & NDR_SCALARS) {
2098                 NDR_CHECK(ndr_push_align(ndr, 5));
2099                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
2100                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->values));
2101                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2102         }
2103         if (ndr_flags & NDR_BUFFERS) {
2104                 if (r->values) {
2105                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_values));
2106                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2107                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2108                         }
2109                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2110                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2111                         }
2112                 }
2113         }
2114         return NDR_ERR_SUCCESS;
2115 }
2116
2117 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValueCtr *r)
2118 {
2119         uint32_t _ptr_values;
2120         uint32_t cntr_values_1;
2121         TALLOC_CTX *_mem_save_values_0;
2122         TALLOC_CTX *_mem_save_values_1;
2123         if (ndr_flags & NDR_SCALARS) {
2124                 NDR_CHECK(ndr_pull_align(ndr, 5));
2125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_values));
2126                 if (r->num_values > 10485760) {
2127                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2128                 }
2129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_values));
2130                 if (_ptr_values) {
2131                         NDR_PULL_ALLOC(ndr, r->values);
2132                 } else {
2133                         r->values = NULL;
2134                 }
2135                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2136         }
2137         if (ndr_flags & NDR_BUFFERS) {
2138                 if (r->values) {
2139                         _mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
2140                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2141                         NDR_CHECK(ndr_pull_array_size(ndr, &r->values));
2142                         NDR_PULL_ALLOC_N(ndr, r->values, ndr_get_array_size(ndr, &r->values));
2143                         _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
2144                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2145                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2146                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2147                         }
2148                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2149                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2150                         }
2151                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
2152                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_0, 0);
2153                 }
2154                 if (r->values) {
2155                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->values, r->num_values));
2156                 }
2157         }
2158         return NDR_ERR_SUCCESS;
2159 }
2160
2161 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValueCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValueCtr *r)
2162 {
2163         uint32_t cntr_values_1;
2164         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValueCtr");
2165         ndr->depth++;
2166         ndr_print_uint32(ndr, "num_values", r->num_values);
2167         ndr_print_ptr(ndr, "values", r->values);
2168         ndr->depth++;
2169         if (r->values) {
2170                 ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->num_values);
2171                 ndr->depth++;
2172                 for (cntr_values_1=0;cntr_values_1<r->num_values;cntr_values_1++) {
2173                         char *idx_1=NULL;
2174                         if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
2175                                 ndr_print_drsuapi_DsAttributeValue(ndr, "values", &r->values[cntr_values_1]);
2176                                 free(idx_1);
2177                         }
2178                 }
2179                 ndr->depth--;
2180         }
2181         ndr->depth--;
2182         ndr->depth--;
2183 }
2184
2185 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2186 {
2187         if (ndr_flags & NDR_SCALARS) {
2188                 NDR_CHECK(ndr_push_align(ndr, 4));
2189                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
2190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2191                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2192                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2193                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2194                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2195                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2196         }
2197         if (ndr_flags & NDR_BUFFERS) {
2198                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2199         }
2200         return NDR_ERR_SUCCESS;
2201 }
2202
2203 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3 *r)
2204 {
2205         if (ndr_flags & NDR_SCALARS) {
2206                 NDR_CHECK(ndr_pull_align(ndr, 4));
2207                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2208                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2209                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2210                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2212                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2213                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2214         }
2215         if (ndr_flags & NDR_BUFFERS) {
2216                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2217         }
2218         return NDR_ERR_SUCCESS;
2219 }
2220
2221 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2222 {
2223         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3");
2224         ndr->depth++;
2225         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);
2226         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);
2227         ndr_print_GUID(ndr, "guid", &r->guid);
2228         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2229         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2230         ndr_print_string(ndr, "dn", r->dn);
2231         ndr->depth--;
2232 }
2233
2234 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3(const struct drsuapi_DsReplicaObjectIdentifier3 *r, struct smb_iconv_convenience *ic, int flags)
2235 {
2236         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3, ic);
2237 }
2238
2239 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2240 {
2241         if (ndr_flags & NDR_SCALARS) {
2242                 NDR_CHECK(ndr_push_align(ndr, 4));
2243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(r, ndr->iconv_convenience, ndr->flags)));
2244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2245                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2246                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2248                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->binary.length + 4));
2250                 {
2251                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2253                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
2254                         ndr->flags = _flags_save_DATA_BLOB;
2255                 }
2256                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2257         }
2258         if (ndr_flags & NDR_BUFFERS) {
2259                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2260         }
2261         return NDR_ERR_SUCCESS;
2262 }
2263
2264 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2265 {
2266         if (ndr_flags & NDR_SCALARS) {
2267                 NDR_CHECK(ndr_pull_align(ndr, 4));
2268                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2270                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2271                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2272                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2273                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2274                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
2275                 {
2276                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2278                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
2279                         ndr->flags = _flags_save_DATA_BLOB;
2280                 }
2281                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2282         }
2283         if (ndr_flags & NDR_BUFFERS) {
2284                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2285         }
2286         return NDR_ERR_SUCCESS;
2287 }
2288
2289 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2290 {
2291         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3Binary");
2292         ndr->depth++;
2293         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);
2294         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);
2295         ndr_print_GUID(ndr, "guid", &r->guid);
2296         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2297         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2298         ndr_print_string(ndr, "dn", r->dn);
2299         ndr_print_uint32(ndr, "__ndr_size_binary", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->binary.length + 4:r->__ndr_size_binary);
2300         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
2301         ndr->depth--;
2302 }
2303
2304 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttribute *r)
2305 {
2306         if (ndr_flags & NDR_SCALARS) {
2307                 NDR_CHECK(ndr_push_align(ndr, 5));
2308                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2309                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2310                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2311         }
2312         if (ndr_flags & NDR_BUFFERS) {
2313                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2314         }
2315         return NDR_ERR_SUCCESS;
2316 }
2317
2318 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttribute *r)
2319 {
2320         if (ndr_flags & NDR_SCALARS) {
2321                 NDR_CHECK(ndr_pull_align(ndr, 5));
2322                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2323                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2324                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2325         }
2326         if (ndr_flags & NDR_BUFFERS) {
2327                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2328         }
2329         return NDR_ERR_SUCCESS;
2330 }
2331
2332 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttribute *r)
2333 {
2334         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttribute");
2335         ndr->depth++;
2336         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2337         ndr_print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr);
2338         ndr->depth--;
2339 }
2340
2341 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttributeCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttributeCtr *r)
2342 {
2343         uint32_t cntr_attributes_1;
2344         if (ndr_flags & NDR_SCALARS) {
2345                 NDR_CHECK(ndr_push_align(ndr, 5));
2346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2347                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
2348                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2349         }
2350         if (ndr_flags & NDR_BUFFERS) {
2351                 if (r->attributes) {
2352                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attributes));
2353                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2354                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2355                         }
2356                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2357                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2358                         }
2359                 }
2360         }
2361         return NDR_ERR_SUCCESS;
2362 }
2363
2364 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttributeCtr *r)
2365 {
2366         uint32_t _ptr_attributes;
2367         uint32_t cntr_attributes_1;
2368         TALLOC_CTX *_mem_save_attributes_0;
2369         TALLOC_CTX *_mem_save_attributes_1;
2370         if (ndr_flags & NDR_SCALARS) {
2371                 NDR_CHECK(ndr_pull_align(ndr, 5));
2372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attributes));
2373                 if (r->num_attributes > 1048576) {
2374                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2375                 }
2376                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
2377                 if (_ptr_attributes) {
2378                         NDR_PULL_ALLOC(ndr, r->attributes);
2379                 } else {
2380                         r->attributes = NULL;
2381                 }
2382                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2383         }
2384         if (ndr_flags & NDR_BUFFERS) {
2385                 if (r->attributes) {
2386                         _mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2387                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2388                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
2389                         NDR_PULL_ALLOC_N(ndr, r->attributes, ndr_get_array_size(ndr, &r->attributes));
2390                         _mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2391                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2392                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2393                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2394                         }
2395                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2396                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2397                         }
2398                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
2399                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);
2400                 }
2401                 if (r->attributes) {
2402                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->num_attributes));
2403                 }
2404         }
2405         return NDR_ERR_SUCCESS;
2406 }
2407
2408 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttributeCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttributeCtr *r)
2409 {
2410         uint32_t cntr_attributes_1;
2411         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttributeCtr");
2412         ndr->depth++;
2413         ndr_print_uint32(ndr, "num_attributes", r->num_attributes);
2414         ndr_print_ptr(ndr, "attributes", r->attributes);
2415         ndr->depth++;
2416         if (r->attributes) {
2417                 ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->num_attributes);
2418                 ndr->depth++;
2419                 for (cntr_attributes_1=0;cntr_attributes_1<r->num_attributes;cntr_attributes_1++) {
2420                         char *idx_1=NULL;
2421                         if (asprintf(&idx_1, "[%d]", cntr_attributes_1) != -1) {
2422                                 ndr_print_drsuapi_DsReplicaAttribute(ndr, "attributes", &r->attributes[cntr_attributes_1]);
2423                                 free(idx_1);
2424                         }
2425                 }
2426                 ndr->depth--;
2427         }
2428         ndr->depth--;
2429         ndr->depth--;
2430 }
2431
2432 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2433 {
2434         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2435         return NDR_ERR_SUCCESS;
2436 }
2437
2438 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2439 {
2440         uint32_t v;
2441         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2442         *r = v;
2443         return NDR_ERR_SUCCESS;
2444 }
2445
2446 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2447 {
2448         ndr_print_uint32(ndr, name, r);
2449         ndr->depth++;
2450         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER", DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER, r);
2451         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC", DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC, r);
2452         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY", DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY, r);
2453         ndr->depth--;
2454 }
2455
2456 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObject(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObject *r)
2457 {
2458         if (ndr_flags & NDR_SCALARS) {
2459                 NDR_CHECK(ndr_push_align(ndr, 5));
2460                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2461                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, r->flags));
2462                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2463                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2464         }
2465         if (ndr_flags & NDR_BUFFERS) {
2466                 if (r->identifier) {
2467                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2468                 }
2469                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2470         }
2471         return NDR_ERR_SUCCESS;
2472 }
2473
2474 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObject *r)
2475 {
2476         uint32_t _ptr_identifier;
2477         TALLOC_CTX *_mem_save_identifier_0;
2478         if (ndr_flags & NDR_SCALARS) {
2479                 NDR_CHECK(ndr_pull_align(ndr, 5));
2480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2481                 if (_ptr_identifier) {
2482                         NDR_PULL_ALLOC(ndr, r->identifier);
2483                 } else {
2484                         r->identifier = NULL;
2485                 }
2486                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, &r->flags));
2487                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2488                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2489         }
2490         if (ndr_flags & NDR_BUFFERS) {
2491                 if (r->identifier) {
2492                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2493                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2494                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2495                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2496                 }
2497                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2498         }
2499         return NDR_ERR_SUCCESS;
2500 }
2501
2502 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObject(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObject *r)
2503 {
2504         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObject");
2505         ndr->depth++;
2506         ndr_print_ptr(ndr, "identifier", r->identifier);
2507         ndr->depth++;
2508         if (r->identifier) {
2509                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2510         }
2511         ndr->depth--;
2512         ndr_print_drsuapi_DsReplicaObjectFlags(ndr, "flags", r->flags);
2513         ndr_print_drsuapi_DsReplicaAttributeCtr(ndr, "attribute_ctr", &r->attribute_ctr);
2514         ndr->depth--;
2515 }
2516
2517 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaData *r)
2518 {
2519         if (ndr_flags & NDR_SCALARS) {
2520                 NDR_CHECK(ndr_push_align(ndr, 8));
2521                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2522                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
2523                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2524                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
2525                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2526         }
2527         if (ndr_flags & NDR_BUFFERS) {
2528         }
2529         return NDR_ERR_SUCCESS;
2530 }
2531
2532 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaData *r)
2533 {
2534         if (ndr_flags & NDR_SCALARS) {
2535                 NDR_CHECK(ndr_pull_align(ndr, 8));
2536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2537                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
2538                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2539                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
2540                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2541         }
2542         if (ndr_flags & NDR_BUFFERS) {
2543         }
2544         return NDR_ERR_SUCCESS;
2545 }
2546
2547 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaData *r)
2548 {
2549         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaData");
2550         ndr->depth++;
2551         ndr_print_uint32(ndr, "version", r->version);
2552         ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
2553         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
2554         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
2555         ndr->depth--;
2556 }
2557
2558 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaDataCtr *r)
2559 {
2560         uint32_t cntr_meta_data_0;
2561         if (ndr_flags & NDR_SCALARS) {
2562                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
2563                 NDR_CHECK(ndr_push_align(ndr, 8));
2564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2565                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2566                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2567                 }
2568                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2569         }
2570         if (ndr_flags & NDR_BUFFERS) {
2571         }
2572         return NDR_ERR_SUCCESS;
2573 }
2574
2575 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaDataCtr *r)
2576 {
2577         uint32_t cntr_meta_data_0;
2578         TALLOC_CTX *_mem_save_meta_data_0;
2579         if (ndr_flags & NDR_SCALARS) {
2580                 NDR_CHECK(ndr_pull_array_size(ndr, &r->meta_data));
2581                 NDR_CHECK(ndr_pull_align(ndr, 8));
2582                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2583                 if (r->count > 1048576) {
2584                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2585                 }
2586                 NDR_PULL_ALLOC_N(ndr, r->meta_data, ndr_get_array_size(ndr, &r->meta_data));
2587                 _mem_save_meta_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2588                 NDR_PULL_SET_MEM_CTX(ndr, r->meta_data, 0);
2589                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2590                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2591                 }
2592                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_0, 0);
2593                 if (r->meta_data) {
2594                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->meta_data, r->count));
2595                 }
2596                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2597         }
2598         if (ndr_flags & NDR_BUFFERS) {
2599         }
2600         return NDR_ERR_SUCCESS;
2601 }
2602
2603 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaDataCtr *r)
2604 {
2605         uint32_t cntr_meta_data_0;
2606         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaDataCtr");
2607         ndr->depth++;
2608         ndr_print_uint32(ndr, "count", r->count);
2609         ndr->print(ndr, "%s: ARRAY(%d)", "meta_data", (int)r->count);
2610         ndr->depth++;
2611         for (cntr_meta_data_0=0;cntr_meta_data_0<r->count;cntr_meta_data_0++) {
2612                 char *idx_0=NULL;
2613                 if (asprintf(&idx_0, "[%d]", cntr_meta_data_0) != -1) {
2614                         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data[cntr_meta_data_0]);
2615                         free(idx_0);
2616                 }
2617         }
2618         ndr->depth--;
2619         ndr->depth--;
2620 }
2621
2622 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItemEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItemEx *r)
2623 {
2624         if (ndr_flags & NDR_SCALARS) {
2625                 NDR_CHECK(ndr_push_align(ndr, 5));
2626                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
2627                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_nc_prefix));
2629                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parent_object_guid));
2630                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->meta_data_ctr));
2631                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2632         }
2633         if (ndr_flags & NDR_BUFFERS) {
2634                 if (r->next_object) {
2635                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2636                 }
2637                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2638                 if (r->parent_object_guid) {
2639                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2640                 }
2641                 if (r->meta_data_ctr) {
2642                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2643                 }
2644         }
2645         return NDR_ERR_SUCCESS;
2646 }
2647
2648 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItemEx *r)
2649 {
2650         uint32_t _ptr_next_object;
2651         TALLOC_CTX *_mem_save_next_object_0;
2652         uint32_t _ptr_parent_object_guid;
2653         TALLOC_CTX *_mem_save_parent_object_guid_0;
2654         uint32_t _ptr_meta_data_ctr;
2655         TALLOC_CTX *_mem_save_meta_data_ctr_0;
2656         if (ndr_flags & NDR_SCALARS) {
2657                 NDR_CHECK(ndr_pull_align(ndr, 5));
2658                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
2659                 if (_ptr_next_object) {
2660                         NDR_PULL_ALLOC(ndr, r->next_object);
2661                 } else {
2662                         r->next_object = NULL;
2663                 }
2664                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2665                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_nc_prefix));
2666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parent_object_guid));
2667                 if (_ptr_parent_object_guid) {
2668                         NDR_PULL_ALLOC(ndr, r->parent_object_guid);
2669                 } else {
2670                         r->parent_object_guid = NULL;
2671                 }
2672                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_meta_data_ctr));
2673                 if (_ptr_meta_data_ctr) {
2674                         NDR_PULL_ALLOC(ndr, r->meta_data_ctr);
2675                 } else {
2676                         r->meta_data_ctr = NULL;
2677                 }
2678                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2679         }
2680         if (ndr_flags & NDR_BUFFERS) {
2681                 if (r->next_object) {
2682                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2683                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
2684                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
2686                 }
2687                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2688                 if (r->parent_object_guid) {
2689                         _mem_save_parent_object_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2690                         NDR_PULL_SET_MEM_CTX(ndr, r->parent_object_guid, 0);
2691                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2692                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_object_guid_0, 0);
2693                 }
2694                 if (r->meta_data_ctr) {
2695                         _mem_save_meta_data_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2696                         NDR_PULL_SET_MEM_CTX(ndr, r->meta_data_ctr, 0);
2697                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2698                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_ctr_0, 0);
2699                 }
2700         }
2701         return NDR_ERR_SUCCESS;
2702 }
2703
2704 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1 *r)
2705 {
2706         if (ndr_flags & NDR_SCALARS) {
2707                 NDR_CHECK(ndr_push_align(ndr, 8));
2708                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2709                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2710                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2711                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2712                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2714                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2715                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55));
2718                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2719                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2720                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2721         }
2722         if (ndr_flags & NDR_BUFFERS) {
2723                 if (r->naming_context) {
2724                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2725                 }
2726                 if (r->uptodateness_vector) {
2727                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2728                 }
2729                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2730                 if (r->first_object) {
2731                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2732                 }
2733         }
2734         return NDR_ERR_SUCCESS;
2735 }
2736
2737 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1 *r)
2738 {
2739         uint32_t _ptr_naming_context;
2740         TALLOC_CTX *_mem_save_naming_context_0;
2741         uint32_t _ptr_uptodateness_vector;
2742         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2743         uint32_t _ptr_first_object;
2744         TALLOC_CTX *_mem_save_first_object_0;
2745         if (ndr_flags & NDR_SCALARS) {
2746                 NDR_CHECK(ndr_pull_align(ndr, 8));
2747                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2748                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2749                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2750                 if (_ptr_naming_context) {
2751                         NDR_PULL_ALLOC(ndr, r->naming_context);
2752                 } else {
2753                         r->naming_context = NULL;
2754                 }
2755                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2756                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2757                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2758                 if (_ptr_uptodateness_vector) {
2759                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2760                 } else {
2761                         r->uptodateness_vector = NULL;
2762                 }
2763                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2764                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2766                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2767                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2768                 if (_ptr_first_object) {
2769                         NDR_PULL_ALLOC(ndr, r->first_object);
2770                 } else {
2771                         r->first_object = NULL;
2772                 }
2773                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2774                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2775         }
2776         if (ndr_flags & NDR_BUFFERS) {
2777                 if (r->naming_context) {
2778                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2779                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2780                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2781                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2782                 }
2783                 if (r->uptodateness_vector) {
2784                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2785                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2786                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2787                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2788                 }
2789                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2790                 if (r->first_object) {
2791                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2792                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2793                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2794                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2795                 }
2796         }
2797         return NDR_ERR_SUCCESS;
2798 }
2799
2800 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1 *r)
2801 {
2802         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1");
2803         ndr->depth++;
2804         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2805         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2806         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2807         ndr->depth++;
2808         if (r->naming_context) {
2809                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2810         }
2811         ndr->depth--;
2812         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2813         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2814         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2815         ndr->depth++;
2816         if (r->uptodateness_vector) {
2817                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2818         }
2819         ndr->depth--;
2820         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2821         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2822         ndr_print_uint32(ndr, "object_count", r->object_count);
2823         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);
2824         ndr_print_ptr(ndr, "first_object", r->first_object);
2825         ndr->depth++;
2826         if (r->first_object) {
2827                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2828         }
2829         ndr->depth--;
2830         ndr_print_uint32(ndr, "more_data", r->more_data);
2831         ndr->depth--;
2832 }
2833
2834 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr1(const struct drsuapi_DsGetNCChangesCtr1 *r, struct smb_iconv_convenience *ic, int flags)
2835 {
2836         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr1, ic);
2837 }
2838
2839 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsLinkedAttributeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2840 {
2841         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2842         return NDR_ERR_SUCCESS;
2843 }
2844
2845 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsLinkedAttributeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2846 {
2847         uint32_t v;
2848         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2849         *r = v;
2850         return NDR_ERR_SUCCESS;
2851 }
2852
2853 _PUBLIC_ void ndr_print_drsuapi_DsLinkedAttributeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2854 {
2855         ndr_print_uint32(ndr, name, r);
2856         ndr->depth++;
2857         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE", DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE, r);
2858         ndr->depth--;
2859 }
2860
2861 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaLinkedAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaLinkedAttribute *r)
2862 {
2863         if (ndr_flags & NDR_SCALARS) {
2864                 NDR_CHECK(ndr_push_align(ndr, 8));
2865                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2866                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2867                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2868                 NDR_CHECK(ndr_push_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, r->flags));
2869                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_add_time));
2870                 NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2871                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2872         }
2873         if (ndr_flags & NDR_BUFFERS) {
2874                 if (r->identifier) {
2875                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2876                 }
2877                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2878         }
2879         return NDR_ERR_SUCCESS;
2880 }
2881
2882 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaLinkedAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaLinkedAttribute *r)
2883 {
2884         uint32_t _ptr_identifier;
2885         TALLOC_CTX *_mem_save_identifier_0;
2886         if (ndr_flags & NDR_SCALARS) {
2887                 NDR_CHECK(ndr_pull_align(ndr, 8));
2888                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2889                 if (_ptr_identifier) {
2890                         NDR_PULL_ALLOC(ndr, r->identifier);
2891                 } else {
2892                         r->identifier = NULL;
2893                 }
2894                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2895                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2896                 NDR_CHECK(ndr_pull_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, &r->flags));
2897                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_add_time));
2898                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2899                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2900         }
2901         if (ndr_flags & NDR_BUFFERS) {
2902                 if (r->identifier) {
2903                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2904                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2905                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2906                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2907                 }
2908                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2909         }
2910         return NDR_ERR_SUCCESS;
2911 }
2912
2913 _PUBLIC_ void ndr_print_drsuapi_DsReplicaLinkedAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaLinkedAttribute *r)
2914 {
2915         ndr_print_struct(ndr, name, "drsuapi_DsReplicaLinkedAttribute");
2916         ndr->depth++;
2917         ndr_print_ptr(ndr, "identifier", r->identifier);
2918         ndr->depth++;
2919         if (r->identifier) {
2920                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2921         }
2922         ndr->depth--;
2923         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2924         ndr_print_drsuapi_DsAttributeValue(ndr, "value", &r->value);
2925         ndr_print_drsuapi_DsLinkedAttributeFlags(ndr, "flags", r->flags);
2926         ndr_print_NTTIME_1sec(ndr, "originating_add_time", r->originating_add_time);
2927         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data);
2928         ndr->depth--;
2929 }
2930
2931 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6 *r)
2932 {
2933         uint32_t cntr_linked_attributes_1;
2934         if (ndr_flags & NDR_SCALARS) {
2935                 NDR_CHECK(ndr_push_align(ndr, 8));
2936                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2937                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2938                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2939                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2940                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2942                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2943                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55));
2946                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2947                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_object_count));
2949                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_linked_attributes_count));
2950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2951                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linked_attributes));
2952                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->drs_error));
2953                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2954         }
2955         if (ndr_flags & NDR_BUFFERS) {
2956                 if (r->naming_context) {
2957                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2958                 }
2959                 if (r->uptodateness_vector) {
2960                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2961                 }
2962                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2963                 if (r->first_object) {
2964                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2965                 }
2966                 if (r->linked_attributes) {
2967                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->linked_attributes_count));
2968                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2969                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2970                         }
2971                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2972                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
2973                         }
2974                 }
2975         }
2976         return NDR_ERR_SUCCESS;
2977 }
2978
2979 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6 *r)
2980 {
2981         uint32_t _ptr_naming_context;
2982         TALLOC_CTX *_mem_save_naming_context_0;
2983         uint32_t _ptr_uptodateness_vector;
2984         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2985         uint32_t _ptr_first_object;
2986         TALLOC_CTX *_mem_save_first_object_0;
2987         uint32_t _ptr_linked_attributes;
2988         uint32_t cntr_linked_attributes_1;
2989         TALLOC_CTX *_mem_save_linked_attributes_0;
2990         TALLOC_CTX *_mem_save_linked_attributes_1;
2991         if (ndr_flags & NDR_SCALARS) {
2992                 NDR_CHECK(ndr_pull_align(ndr, 8));
2993                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2994                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2995                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2996                 if (_ptr_naming_context) {
2997                         NDR_PULL_ALLOC(ndr, r->naming_context);
2998                 } else {
2999                         r->naming_context = NULL;
3000                 }
3001                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
3002                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
3003                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
3004                 if (_ptr_uptodateness_vector) {
3005                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
3006                 } else {
3007                         r->uptodateness_vector = NULL;
3008                 }
3009                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
3010                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
3011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
3012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
3013                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
3014                 if (_ptr_first_object) {
3015                         NDR_PULL_ALLOC(ndr, r->first_object);
3016                 } else {
3017                         r->first_object = NULL;
3018                 }
3019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
3020                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_object_count));
3021                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_linked_attributes_count));
3022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linked_attributes_count));
3023                 if (r->linked_attributes_count > 1048576) {
3024                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3025                 }
3026                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linked_attributes));
3027                 if (_ptr_linked_attributes) {
3028                         NDR_PULL_ALLOC(ndr, r->linked_attributes);
3029                 } else {
3030                         r->linked_attributes = NULL;
3031                 }
3032                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->drs_error));
3033                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
3034         }
3035         if (ndr_flags & NDR_BUFFERS) {
3036                 if (r->naming_context) {
3037                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3038                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3039                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3040                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3041                 }
3042                 if (r->uptodateness_vector) {
3043                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
3044                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
3045                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
3046                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
3047                 }
3048                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
3049                 if (r->first_object) {
3050                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
3051                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
3052                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
3053                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
3054                 }
3055                 if (r->linked_attributes) {
3056                         _mem_save_linked_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
3057                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3058                         NDR_CHECK(ndr_pull_array_size(ndr, &r->linked_attributes));
3059                         NDR_PULL_ALLOC_N(ndr, r->linked_attributes, ndr_get_array_size(ndr, &r->linked_attributes));
3060                         _mem_save_linked_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
3061                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3062                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3063                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
3064                         }
3065                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3066                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
3067                         }
3068                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_1, 0);
3069                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_0, 0);
3070                 }
3071                 if (r->linked_attributes) {
3072                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->linked_attributes, r->linked_attributes_count));
3073                 }
3074         }
3075         return NDR_ERR_SUCCESS;
3076 }
3077
3078 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6 *r)
3079 {
3080         uint32_t cntr_linked_attributes_1;
3081         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6");
3082         ndr->depth++;
3083         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
3084         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
3085         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3086         ndr->depth++;
3087         if (r->naming_context) {
3088                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3089         }
3090         ndr->depth--;
3091         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
3092         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
3093         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
3094         ndr->depth++;
3095         if (r->uptodateness_vector) {
3096                 ndr_print_drsuapi_DsReplicaCursor2CtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
3097         }
3098         ndr->depth--;
3099         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
3100         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
3101         ndr_print_uint32(ndr, "object_count", r->object_count);
3102         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);
3103         ndr_print_ptr(ndr, "first_object", r->first_object);
3104         ndr->depth++;
3105         if (r->first_object) {
3106                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
3107         }
3108         ndr->depth--;
3109         ndr_print_uint32(ndr, "more_data", r->more_data);
3110         ndr_print_uint32(ndr, "nc_object_count", r->nc_object_count);
3111         ndr_print_uint32(ndr, "nc_linked_attributes_count", r->nc_linked_attributes_count);
3112         ndr_print_uint32(ndr, "linked_attributes_count", r->linked_attributes_count);
3113         ndr_print_ptr(ndr, "linked_attributes", r->linked_attributes);
3114         ndr->depth++;
3115         if (r->linked_attributes) {
3116                 ndr->print(ndr, "%s: ARRAY(%d)", "linked_attributes", (int)r->linked_attributes_count);
3117                 ndr->depth++;
3118                 for (cntr_linked_attributes_1=0;cntr_linked_attributes_1<r->linked_attributes_count;cntr_linked_attributes_1++) {
3119                         char *idx_1=NULL;
3120                         if (asprintf(&idx_1, "[%d]", cntr_linked_attributes_1) != -1) {
3121                                 ndr_print_drsuapi_DsReplicaLinkedAttribute(ndr, "linked_attributes", &r->linked_attributes[cntr_linked_attributes_1]);
3122                                 free(idx_1);
3123                         }
3124                 }
3125                 ndr->depth--;
3126         }
3127         ndr->depth--;
3128         ndr_print_WERROR(ndr, "drs_error", r->drs_error);
3129         ndr->depth--;
3130 }
3131
3132 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr6(const struct drsuapi_DsGetNCChangesCtr6 *r, struct smb_iconv_convenience *ic, int flags)
3133 {
3134         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr6, ic);
3135 }
3136
3137 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3138 {
3139         if (ndr_flags & NDR_SCALARS) {
3140                 NDR_CHECK(ndr_push_align(ndr, 1));
3141                 {
3142                         struct ndr_push *_ndr_ctr1;
3143                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3144                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3145                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3146                 }
3147                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3148         }
3149         if (ndr_flags & NDR_BUFFERS) {
3150         }
3151         return NDR_ERR_SUCCESS;
3152 }
3153
3154 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1TS *r)
3155 {
3156         if (ndr_flags & NDR_SCALARS) {
3157                 NDR_CHECK(ndr_pull_align(ndr, 1));
3158                 {
3159                         struct ndr_pull *_ndr_ctr1;
3160                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3161                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3162                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3163                 }
3164                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3165         }
3166         if (ndr_flags & NDR_BUFFERS) {
3167         }
3168         return NDR_ERR_SUCCESS;
3169 }
3170
3171 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3172 {
3173         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1TS");
3174         ndr->depth++;
3175         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3176         ndr->depth--;
3177 }
3178
3179 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3180 {
3181         if (ndr_flags & NDR_SCALARS) {
3182                 NDR_CHECK(ndr_push_align(ndr, 1));
3183                 {
3184                         struct ndr_push *_ndr_ctr6;
3185                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3186                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3187                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3188                 }
3189                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3190         }
3191         if (ndr_flags & NDR_BUFFERS) {
3192         }
3193         return NDR_ERR_SUCCESS;
3194 }
3195
3196 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6TS *r)
3197 {
3198         if (ndr_flags & NDR_SCALARS) {
3199                 NDR_CHECK(ndr_pull_align(ndr, 1));
3200                 {
3201                         struct ndr_pull *_ndr_ctr6;
3202                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3203                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3204                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3205                 }
3206                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3207         }
3208         if (ndr_flags & NDR_BUFFERS) {
3209         }
3210         return NDR_ERR_SUCCESS;
3211 }
3212
3213 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3214 {
3215         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6TS");
3216         ndr->depth++;
3217         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3218         ndr->depth--;
3219 }
3220
3221 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3222 {
3223         uint32_t _ptr_ts;
3224         TALLOC_CTX *_mem_save_ts_0;
3225         if (ndr_flags & NDR_SCALARS) {
3226                 NDR_CHECK(ndr_pull_align(ndr, 5));
3227                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3230                 if (_ptr_ts) {
3231                         NDR_PULL_ALLOC(ndr, r->ts);
3232                 } else {
3233                         r->ts = NULL;
3234                 }
3235                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3236         }
3237         if (ndr_flags & NDR_BUFFERS) {
3238                 if (r->ts) {
3239                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3240                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3241                         {
3242                                 struct ndr_pull *_ndr_ts;
3243                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3244                                 {
3245                                         struct ndr_pull *_ndr_ts_compressed;
3246                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3247                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3248                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3249                                 }
3250                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3251                         }
3252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3253                 }
3254         }
3255         return NDR_ERR_SUCCESS;
3256 }
3257
3258 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3259 {
3260         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr1");
3261         ndr->depth++;
3262         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3263         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3264         ndr_print_ptr(ndr, "ts", r->ts);
3265         ndr->depth++;
3266         if (r->ts) {
3267                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3268         }
3269         ndr->depth--;
3270         ndr->depth--;
3271 }
3272
3273 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3274 {
3275         uint32_t _ptr_ts;
3276         TALLOC_CTX *_mem_save_ts_0;
3277         if (ndr_flags & NDR_SCALARS) {
3278                 NDR_CHECK(ndr_pull_align(ndr, 5));
3279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3281                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3282                 if (_ptr_ts) {
3283                         NDR_PULL_ALLOC(ndr, r->ts);
3284                 } else {
3285                         r->ts = NULL;
3286                 }
3287                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3288         }
3289         if (ndr_flags & NDR_BUFFERS) {
3290                 if (r->ts) {
3291                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3292                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3293                         {
3294                                 struct ndr_pull *_ndr_ts;
3295                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3296                                 {
3297                                         struct ndr_pull *_ndr_ts_compressed;
3298                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3299                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3300                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3301                                 }
3302                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3303                         }
3304                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3305                 }
3306         }
3307         return NDR_ERR_SUCCESS;
3308 }
3309
3310 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3311 {
3312         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr6");
3313         ndr->depth++;
3314         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3315         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3316         ndr_print_ptr(ndr, "ts", r->ts);
3317         ndr->depth++;
3318         if (r->ts) {
3319                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3320         }
3321         ndr->depth--;
3322         ndr->depth--;
3323 }
3324
3325 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3326 {
3327         uint32_t _ptr_ts;
3328         TALLOC_CTX *_mem_save_ts_0;
3329         if (ndr_flags & NDR_SCALARS) {
3330                 NDR_CHECK(ndr_pull_align(ndr, 5));
3331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3333                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3334                 if (_ptr_ts) {
3335                         NDR_PULL_ALLOC(ndr, r->ts);
3336                 } else {
3337                         r->ts = NULL;
3338                 }
3339                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3340         }
3341         if (ndr_flags & NDR_BUFFERS) {
3342                 if (r->ts) {
3343                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3344                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3345                         {
3346                                 struct ndr_pull *_ndr_ts;
3347                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3348                                 {
3349                                         struct ndr_pull *_ndr_ts_compressed;
3350                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3351                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3352                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3353                                 }
3354                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3355                         }
3356                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3357                 }
3358         }
3359         return NDR_ERR_SUCCESS;
3360 }
3361
3362 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3363 {
3364         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr1");
3365         ndr->depth++;
3366         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3367         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3368         ndr_print_ptr(ndr, "ts", r->ts);
3369         ndr->depth++;
3370         if (r->ts) {
3371                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3372         }
3373         ndr->depth--;
3374         ndr->depth--;
3375 }
3376
3377 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3378 {
3379         uint32_t _ptr_ts;
3380         TALLOC_CTX *_mem_save_ts_0;
3381         if (ndr_flags & NDR_SCALARS) {
3382                 NDR_CHECK(ndr_pull_align(ndr, 5));
3383                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3384                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3385                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3386                 if (_ptr_ts) {
3387                         NDR_PULL_ALLOC(ndr, r->ts);
3388                 } else {
3389                         r->ts = NULL;
3390                 }
3391                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3392         }
3393         if (ndr_flags & NDR_BUFFERS) {
3394                 if (r->ts) {
3395                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3396                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3397                         {
3398                                 struct ndr_pull *_ndr_ts;
3399                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3400                                 {
3401                                         struct ndr_pull *_ndr_ts_compressed;
3402                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3403                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3404                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3405                                 }
3406                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3407                         }
3408                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3409                 }
3410         }
3411         return NDR_ERR_SUCCESS;
3412 }
3413
3414 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3415 {
3416         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr6");
3417         ndr->depth++;
3418         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3419         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3420         ndr_print_ptr(ndr, "ts", r->ts);
3421         ndr->depth++;
3422         if (r->ts) {
3423                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3424         }
3425         ndr->depth--;
3426         ndr->depth--;
3427 }
3428
3429 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressionType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType r)
3430 {
3431         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
3432         return NDR_ERR_SUCCESS;
3433 }
3434
3435 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressionType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType *r)
3436 {
3437         uint16_t v;
3438         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
3439         *r = v;
3440         return NDR_ERR_SUCCESS;
3441 }
3442
3443 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressionType(struct ndr_print *ndr, const char *name, enum drsuapi_DsGetNCChangesCompressionType r)
3444 {
3445         const char *val = NULL;
3446
3447         switch (r) {
3448                 case DRSUAPI_COMPRESSION_TYPE_MSZIP: val = "DRSUAPI_COMPRESSION_TYPE_MSZIP"; break;
3449                 case DRSUAPI_COMPRESSION_TYPE_XPRESS: val = "DRSUAPI_COMPRESSION_TYPE_XPRESS"; break;
3450         }
3451         ndr_print_enum(ndr, name, "ENUM", val, r);
3452 }
3453
3454 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3455 {
3456         {
3457                 uint32_t _flags_save_UNION = ndr->flags;
3458                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3459                 if (ndr_flags & NDR_SCALARS) {
3460                         int level = ndr_push_get_switch_value(ndr, r);
3461                         NDR_CHECK(ndr_push_union_align(ndr, 5));
3462                         switch (level) {
3463                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3464                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3465                                 break; }
3466
3467                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3468                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3469                                 break; }
3470
3471                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3472                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3473                                 break; }
3474
3475                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3476                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3477                                 break; }
3478
3479                                 default:
3480                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3481                         }
3482                 }
3483                 if (ndr_flags & NDR_BUFFERS) {
3484                         int level = ndr_push_get_switch_value(ndr, r);
3485                         switch (level) {
3486                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3487                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3488                                 break;
3489
3490                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3491                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3492                                 break;
3493
3494                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3495                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3496                                 break;
3497
3498                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3499                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3500                                 break;
3501
3502                                 default:
3503                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3504                         }
3505                 }
3506                 ndr->flags = _flags_save_UNION;
3507         }
3508         return NDR_ERR_SUCCESS;
3509 }
3510
3511 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCompressedCtr *r)
3512 {
3513         int level;
3514         {
3515                 uint32_t _flags_save_UNION = ndr->flags;
3516                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3517                 level = ndr_pull_get_switch_value(ndr, r);
3518                 if (ndr_flags & NDR_SCALARS) {
3519                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
3520                         switch (level) {
3521                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3522                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3523                                 break; }
3524
3525                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3526                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3527                                 break; }
3528
3529                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3530                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3531                                 break; }
3532
3533                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3534                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3535                                 break; }
3536
3537                                 default:
3538                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3539                         }
3540                 }
3541                 if (ndr_flags & NDR_BUFFERS) {
3542                         switch (level) {
3543                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3544                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3545                                 break;
3546
3547                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3548                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3549                                 break;
3550
3551                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3552                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3553                                 break;
3554
3555                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3556                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3557                                 break;
3558
3559                                 default:
3560                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3561                         }
3562                 }
3563                 ndr->flags = _flags_save_UNION;
3564         }
3565         return NDR_ERR_SUCCESS;
3566 }
3567
3568 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3569 {
3570         int level;
3571         {
3572                 uint32_t _flags_save_UNION = ndr->flags;
3573                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3574                 level = ndr_print_get_switch_value(ndr, r);
3575                 ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCompressedCtr");
3576                 switch (level) {
3577                         case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3578                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3579                         break;
3580
3581                         case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3582                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, "mszip6", &r->mszip6);
3583                         break;
3584
3585                         case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3586                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, "xpress1", &r->xpress1);
3587                         break;
3588
3589                         case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3590                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, "xpress6", &r->xpress6);
3591                         break;
3592
3593                         default:
3594                                 ndr_print_bad_level(ndr, name, level);
3595                 }
3596                 ndr->flags = _flags_save_UNION;
3597         }
3598 }
3599
3600 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr2 *r)
3601 {
3602         if (ndr_flags & NDR_SCALARS) {
3603                 NDR_CHECK(ndr_push_align(ndr, 5));
3604                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3605                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3606         }
3607         if (ndr_flags & NDR_BUFFERS) {
3608                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3609         }
3610         return NDR_ERR_SUCCESS;
3611 }
3612
3613 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr2 *r)
3614 {
3615         if (ndr_flags & NDR_SCALARS) {
3616                 NDR_CHECK(ndr_pull_align(ndr, 5));
3617                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3618                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3619         }
3620         if (ndr_flags & NDR_BUFFERS) {
3621                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3622         }
3623         return NDR_ERR_SUCCESS;
3624 }
3625
3626 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr2 *r)
3627 {
3628         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr2");
3629         ndr->depth++;
3630         ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3631         ndr->depth--;
3632 }
3633
3634 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr7 *r)
3635 {
3636         if (ndr_flags & NDR_SCALARS) {
3637                 NDR_CHECK(ndr_push_align(ndr, 5));
3638                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
3639                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, r->type));
3640                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3641                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3642                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3643         }
3644         if (ndr_flags & NDR_BUFFERS) {
3645                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3646         }
3647         return NDR_ERR_SUCCESS;
3648 }
3649
3650 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr7 *r)
3651 {
3652         if (ndr_flags & NDR_SCALARS) {
3653                 NDR_CHECK(ndr_pull_align(ndr, 5));
3654                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
3655                 if (r->level < 0 || r->level > 6) {
3656                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3657                 }
3658                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, &r->type));
3659                 if (r->type < 2 || r->type > 3) {
3660                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3661                 }
3662                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3663                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3664                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3665         }
3666         if (ndr_flags & NDR_BUFFERS) {
3667                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3668         }
3669         return NDR_ERR_SUCCESS;
3670 }
3671
3672 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr7(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr7 *r)
3673 {
3674         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr7");
3675         ndr->depth++;
3676         ndr_print_int32(ndr, "level", r->level);
3677         ndr_print_drsuapi_DsGetNCChangesCompressionType(ndr, "type", r->type);
3678         ndr_print_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16));
3679         ndr_print_drsuapi_DsGetNCChangesCompressedCtr(ndr, "ctr", &r->ctr);
3680         ndr->depth--;
3681 }
3682
3683 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCtr *r)
3684 {
3685         if (ndr_flags & NDR_SCALARS) {
3686                 int level = ndr_push_get_switch_value(ndr, r);
3687                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3688                 NDR_CHECK(ndr_push_union_align(ndr, 8));
3689                 switch (level) {
3690                         case 1: {
3691                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3692                         break; }
3693
3694                         case 2: {
3695                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3696                         break; }
3697
3698                         case 6: {
3699                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3700                         break; }
3701
3702                         case 7: {
3703                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3704                         break; }
3705
3706                         default:
3707                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3708                 }
3709         }
3710         if (ndr_flags & NDR_BUFFERS) {
3711                 int level = ndr_push_get_switch_value(ndr, r);
3712                 switch (level) {
3713                         case 1:
3714                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3715                         break;
3716
3717                         case 2:
3718                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3719                         break;
3720
3721                         case 6:
3722                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3723                         break;
3724
3725                         case 7:
3726                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3727                         break;
3728
3729                         default:
3730                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3731                 }
3732         }
3733         return NDR_ERR_SUCCESS;
3734 }
3735
3736 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCtr *r)
3737 {
3738         int level;
3739         int32_t _level;
3740         level = ndr_pull_get_switch_value(ndr, r);
3741         if (ndr_flags & NDR_SCALARS) {
3742                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3743                 if (_level != level) {
3744                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3745                 }
3746                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
3747                 switch (level) {
3748                         case 1: {
3749                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3750                         break; }
3751
3752                         case 2: {
3753                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3754                         break; }
3755
3756                         case 6: {
3757                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3758                         break; }
3759
3760                         case 7: {
3761                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3762                         break; }
3763
3764                         default:
3765                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3766                 }
3767         }
3768         if (ndr_flags & NDR_BUFFERS) {
3769                 switch (level) {
3770                         case 1:
3771                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3772                         break;
3773
3774                         case 2:
3775                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3776                         break;
3777
3778                         case 6:
3779                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3780                         break;
3781
3782                         case 7:
3783                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3784                         break;
3785
3786                         default:
3787                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3788                 }
3789         }
3790         return NDR_ERR_SUCCESS;
3791 }
3792
3793 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCtr *r)
3794 {
3795         int level;
3796         level = ndr_print_get_switch_value(ndr, r);
3797         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCtr");
3798         switch (level) {
3799                 case 1:
3800                         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3801                 break;
3802
3803                 case 2:
3804                         ndr_print_drsuapi_DsGetNCChangesCtr2(ndr, "ctr2", &r->ctr2);
3805                 break;
3806
3807                 case 6:
3808                         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3809                 break;
3810
3811                 case 7:
3812                         ndr_print_drsuapi_DsGetNCChangesCtr7(ndr, "ctr7", &r->ctr7);
3813                 break;
3814
3815                 default:
3816                         ndr_print_bad_level(ndr, name, level);
3817         }
3818 }
3819
3820 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3821 {
3822         if (ndr_flags & NDR_SCALARS) {
3823                 NDR_CHECK(ndr_push_align(ndr, 5));
3824                 if (r->naming_context == NULL) {
3825                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3826                 }
3827                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3828                 if (r->dest_dsa_dns_name == NULL) {
3829                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3830                 }
3831                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3832                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3833                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
3834                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3835         }
3836         if (ndr_flags & NDR_BUFFERS) {
3837                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3838                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3839                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3840                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3841                 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));
3842         }
3843         return NDR_ERR_SUCCESS;
3844 }
3845
3846 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3847 {
3848         uint32_t _ptr_naming_context;
3849         TALLOC_CTX *_mem_save_naming_context_0;
3850         uint32_t _ptr_dest_dsa_dns_name;
3851         if (ndr_flags & NDR_SCALARS) {
3852                 NDR_CHECK(ndr_pull_align(ndr, 5));
3853                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3854                 if (_ptr_naming_context) {
3855                         NDR_PULL_ALLOC(ndr, r->naming_context);
3856                 } else {
3857                         r->naming_context = NULL;
3858                 }
3859                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_dest_dsa_dns_name));
3860                 if (_ptr_dest_dsa_dns_name) {
3861                         NDR_PULL_ALLOC(ndr, r->dest_dsa_dns_name);
3862                 } else {
3863                         r->dest_dsa_dns_name = NULL;
3864                 }
3865                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3866                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
3867                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3868         }
3869         if (ndr_flags & NDR_BUFFERS) {
3870                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3871                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3872                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3873                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3874                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
3875                 NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
3876                 if (ndr_get_array_length(ndr, &r->dest_dsa_dns_name) > ndr_get_array_size(ndr, &r->dest_dsa_dns_name)) {
3877                         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));
3878                 }
3879                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t)));
3880                 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));
3881         }
3882         return NDR_ERR_SUCCESS;
3883 }
3884
3885 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3886 {
3887         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefsRequest1");
3888         ndr->depth++;
3889         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3890         ndr->depth++;
3891         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3892         ndr->depth--;
3893         ndr_print_ptr(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3894         ndr->depth++;
3895         ndr_print_string(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3896         ndr->depth--;
3897         ndr_print_GUID(ndr, "dest_dsa_guid", &r->dest_dsa_guid);
3898         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
3899         ndr->depth--;
3900 }
3901
3902 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3903 {
3904         if (ndr_flags & NDR_SCALARS) {
3905                 int level = ndr_push_get_switch_value(ndr, r);
3906                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3907                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3908                 switch (level) {
3909                         case 1: {
3910                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3911                         break; }
3912
3913                         default:
3914                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3915                 }
3916         }
3917         if (ndr_flags & NDR_BUFFERS) {
3918                 int level = ndr_push_get_switch_value(ndr, r);
3919                 switch (level) {
3920                         case 1:
3921                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3922                         break;
3923
3924                         default:
3925                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3926                 }
3927         }
3928         return NDR_ERR_SUCCESS;
3929 }
3930
3931 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaUpdateRefsRequest *r)
3932 {
3933         int level;
3934         int32_t _level;
3935         level = ndr_pull_get_switch_value(ndr, r);
3936         if (ndr_flags & NDR_SCALARS) {
3937                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3938                 if (_level != level) {
3939                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3940                 }
3941                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3942                 switch (level) {
3943                         case 1: {
3944                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3945                         break; }
3946
3947                         default:
3948                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3949                 }
3950         }
3951         if (ndr_flags & NDR_BUFFERS) {
3952                 switch (level) {
3953                         case 1:
3954                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3955                         break;
3956
3957                         default:
3958                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3959                 }
3960         }
3961         return NDR_ERR_SUCCESS;
3962 }
3963
3964 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3965 {
3966         int level;
3967         level = ndr_print_get_switch_value(ndr, r);
3968         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaUpdateRefsRequest");
3969         switch (level) {
3970                 case 1:
3971                         ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(ndr, "req1", &r->req1);
3972                 break;
3973
3974                 default:
3975                         ndr_print_bad_level(ndr, name, level);
3976         }
3977 }
3978
3979 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest1 *r)
3980 {
3981         if (ndr_flags & NDR_SCALARS) {
3982                 NDR_CHECK(ndr_push_align(ndr, 5));
3983                 if (r->naming_context == NULL) {
3984                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3985                 }
3986                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3987                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
3988                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
3989                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
3990                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3991         }
3992         if (ndr_flags & NDR_BUFFERS) {
3993                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3994                 if (r->source_dsa_address) {
3995                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3996                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3997                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3998                         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));
3999                 }
4000         }
4001         return NDR_ERR_SUCCESS;
4002 }
4003
4004 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest1 *r)
4005 {
4006         uint32_t _ptr_naming_context;
4007         TALLOC_CTX *_mem_save_naming_context_0;
4008         uint32_t _ptr_source_dsa_address;
4009         TALLOC_CTX *_mem_save_source_dsa_address_0;
4010         if (ndr_flags & NDR_SCALARS) {
4011                 NDR_CHECK(ndr_pull_align(ndr, 5));
4012                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4013                 if (_ptr_naming_context) {
4014                         NDR_PULL_ALLOC(ndr, r->naming_context);
4015                 } else {
4016                         r->naming_context = NULL;
4017                 }
4018                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4019                 if (_ptr_source_dsa_address) {
4020                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4021                 } else {
4022                         r->source_dsa_address = NULL;
4023                 }
4024                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4025                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4026                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4027         }
4028         if (ndr_flags & NDR_BUFFERS) {
4029                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4030                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4031                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4032                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4033                 if (r->source_dsa_address) {
4034                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4035                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4036                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4037                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4038                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4039                                 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));
4040                         }
4041                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4042                         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));
4043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4044                 }
4045         }
4046         return NDR_ERR_SUCCESS;
4047 }
4048
4049 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest1 *r)
4050 {
4051         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest1");
4052         ndr->depth++;
4053         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4054         ndr->depth++;
4055         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4056         ndr->depth--;
4057         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4058         ndr->depth++;
4059         if (r->source_dsa_address) {
4060                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4061         }
4062         ndr->depth--;
4063         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4064         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4065         ndr->depth--;
4066 }
4067
4068 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest2 *r)
4069 {
4070         if (ndr_flags & NDR_SCALARS) {
4071                 NDR_CHECK(ndr_push_align(ndr, 5));
4072                 if (r->naming_context == NULL) {
4073                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4074                 }
4075                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_dn));
4077                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_dn));
4078                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4079                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4080                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4081                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4082         }
4083         if (ndr_flags & NDR_BUFFERS) {
4084                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4085                 if (r->source_dsa_dn) {
4086                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4087                 }
4088                 if (r->transport_dn) {
4089                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4090                 }
4091                 if (r->source_dsa_address) {
4092                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4093                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4094                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4095                         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));
4096                 }
4097         }
4098         return NDR_ERR_SUCCESS;
4099 }
4100
4101 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest2 *r)
4102 {
4103         uint32_t _ptr_naming_context;
4104         TALLOC_CTX *_mem_save_naming_context_0;
4105         uint32_t _ptr_source_dsa_dn;
4106         TALLOC_CTX *_mem_save_source_dsa_dn_0;
4107         uint32_t _ptr_transport_dn;
4108         TALLOC_CTX *_mem_save_transport_dn_0;
4109         uint32_t _ptr_source_dsa_address;
4110         TALLOC_CTX *_mem_save_source_dsa_address_0;
4111         if (ndr_flags & NDR_SCALARS) {
4112                 NDR_CHECK(ndr_pull_align(ndr, 5));
4113                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4114                 if (_ptr_naming_context) {
4115                         NDR_PULL_ALLOC(ndr, r->naming_context);
4116                 } else {
4117                         r->naming_context = NULL;
4118                 }
4119                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_dn));
4120                 if (_ptr_source_dsa_dn) {
4121                         NDR_PULL_ALLOC(ndr, r->source_dsa_dn);
4122                 } else {
4123                         r->source_dsa_dn = NULL;
4124                 }
4125                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_dn));
4126                 if (_ptr_transport_dn) {
4127                         NDR_PULL_ALLOC(ndr, r->transport_dn);
4128                 } else {
4129                         r->transport_dn = NULL;
4130                 }
4131                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4132                 if (_ptr_source_dsa_address) {
4133                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4134                 } else {
4135                         r->source_dsa_address = NULL;
4136                 }
4137                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4138                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4139                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4140         }
4141         if (ndr_flags & NDR_BUFFERS) {
4142                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4143                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4144                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4145                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4146                 if (r->source_dsa_dn) {
4147                         _mem_save_source_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4148                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_dn, 0);
4149                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_dn_0, 0);
4151                 }
4152                 if (r->transport_dn) {
4153                         _mem_save_transport_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4154                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_dn, 0);
4155                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4156                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_dn_0, 0);
4157                 }
4158                 if (r->source_dsa_address) {
4159                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4160                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4161                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4162                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4163                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4164                                 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));
4165                         }
4166                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4167                         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));
4168                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4169                 }
4170         }
4171         return NDR_ERR_SUCCESS;
4172 }
4173
4174 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest2 *r)
4175 {
4176         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest2");
4177         ndr->depth++;
4178         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4179         ndr->depth++;
4180         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4181         ndr->depth--;
4182         ndr_print_ptr(ndr, "source_dsa_dn", r->source_dsa_dn);
4183         ndr->depth++;
4184         if (r->source_dsa_dn) {
4185                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "source_dsa_dn", r->source_dsa_dn);
4186         }
4187         ndr->depth--;
4188         ndr_print_ptr(ndr, "transport_dn", r->transport_dn);
4189         ndr->depth++;
4190         if (r->transport_dn) {
4191                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "transport_dn", r->transport_dn);
4192         }
4193         ndr->depth--;
4194         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4195         ndr->depth++;
4196         if (r->source_dsa_address) {
4197                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4198         }
4199         ndr->depth--;
4200         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4201         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4202         ndr->depth--;
4203 }
4204
4205 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaAddRequest *r)
4206 {
4207         if (ndr_flags & NDR_SCALARS) {
4208                 int level = ndr_push_get_switch_value(ndr, r);
4209                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4210                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4211                 switch (level) {
4212                         case 1: {
4213                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4214                         break; }
4215
4216                         case 2: {
4217                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4218                         break; }
4219
4220                         default:
4221                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4222                 }
4223         }
4224         if (ndr_flags & NDR_BUFFERS) {
4225                 int level = ndr_push_get_switch_value(ndr, r);
4226                 switch (level) {
4227                         case 1:
4228                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4229                         break;
4230
4231                         case 2:
4232                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4233                         break;
4234
4235                         default:
4236                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4237                 }
4238         }
4239         return NDR_ERR_SUCCESS;
4240 }
4241
4242 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaAddRequest *r)
4243 {
4244         int level;
4245         int32_t _level;
4246         level = ndr_pull_get_switch_value(ndr, r);
4247         if (ndr_flags & NDR_SCALARS) {
4248                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4249                 if (_level != level) {
4250                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4251                 }
4252                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4253                 switch (level) {
4254                         case 1: {
4255                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4256                         break; }
4257
4258                         case 2: {
4259                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4260                         break; }
4261
4262                         default:
4263                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4264                 }
4265         }
4266         if (ndr_flags & NDR_BUFFERS) {
4267                 switch (level) {
4268                         case 1:
4269                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4270                         break;
4271
4272                         case 2:
4273                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4274                         break;
4275
4276                         default:
4277                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4278                 }
4279         }
4280         return NDR_ERR_SUCCESS;
4281 }
4282
4283 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaAddRequest *r)
4284 {
4285         int level;
4286         level = ndr_print_get_switch_value(ndr, r);
4287         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaAddRequest");
4288         switch (level) {
4289                 case 1:
4290                         ndr_print_drsuapi_DsReplicaAddRequest1(ndr, "req1", &r->req1);
4291                 break;
4292
4293                 case 2:
4294                         ndr_print_drsuapi_DsReplicaAddRequest2(ndr, "req2", &r->req2);
4295                 break;
4296
4297                 default:
4298                         ndr_print_bad_level(ndr, name, level);
4299         }
4300 }
4301
4302 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaDelRequest1 *r)
4303 {
4304         if (ndr_flags & NDR_SCALARS) {
4305                 NDR_CHECK(ndr_push_align(ndr, 5));
4306                 if (r->naming_context == NULL) {
4307                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4308                 }
4309                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4310                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4311                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4312                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4313         }
4314         if (ndr_flags & NDR_BUFFERS) {
4315                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4316                 if (r->source_dsa_address) {
4317                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4318                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4319                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4320                         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));
4321                 }
4322         }
4323         return NDR_ERR_SUCCESS;
4324 }
4325
4326 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaDelRequest1 *r)
4327 {
4328         uint32_t _ptr_naming_context;
4329         TALLOC_CTX *_mem_save_naming_context_0;
4330         uint32_t _ptr_source_dsa_address;
4331         TALLOC_CTX *_mem_save_source_dsa_address_0;
4332         if (ndr_flags & NDR_SCALARS) {
4333                 NDR_CHECK(ndr_pull_align(ndr, 5));
4334                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4335                 if (_ptr_naming_context) {
4336                         NDR_PULL_ALLOC(ndr, r->naming_context);
4337                 } else {
4338                         r->naming_context = NULL;
4339                 }
4340                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4341                 if (_ptr_source_dsa_address) {
4342                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4343                 } else {
4344                         r->source_dsa_address = NULL;
4345                 }
4346                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4347                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4348         }
4349         if (ndr_flags & NDR_BUFFERS) {
4350                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4351                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4352                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4353                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4354                 if (r->source_dsa_address) {
4355                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4356                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4357                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4358                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4359                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4360                                 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));
4361                         }
4362                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4363                         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));
4364                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4365                 }
4366         }
4367         return NDR_ERR_SUCCESS;
4368 }
4369
4370 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaDelRequest1 *r)
4371 {
4372         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDelRequest1");
4373         ndr->depth++;
4374         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4375         ndr->depth++;
4376         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4377         ndr->depth--;
4378         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4379         ndr->depth++;
4380         if (r->source_dsa_address) {
4381                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4382         }
4383         ndr->depth--;
4384         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4385         ndr->depth--;
4386 }
4387
4388 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaDelRequest *r)
4389 {
4390         if (ndr_flags & NDR_SCALARS) {
4391                 int level = ndr_push_get_switch_value(ndr, r);
4392                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4393                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4394                 switch (level) {
4395                         case 1: {
4396                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4397                         break; }
4398
4399                         default:
4400                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4401                 }
4402         }
4403         if (ndr_flags & NDR_BUFFERS) {
4404                 int level = ndr_push_get_switch_value(ndr, r);
4405                 switch (level) {
4406                         case 1:
4407                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4408                         break;
4409
4410                         default:
4411                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4412                 }
4413         }
4414         return NDR_ERR_SUCCESS;
4415 }
4416
4417 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaDelRequest *r)
4418 {
4419         int level;
4420         int32_t _level;
4421         level = ndr_pull_get_switch_value(ndr, r);
4422         if (ndr_flags & NDR_SCALARS) {
4423                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4424                 if (_level != level) {
4425                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4426                 }
4427                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4428                 switch (level) {
4429                         case 1: {
4430                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4431                         break; }
4432
4433                         default:
4434                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4435                 }
4436         }
4437         if (ndr_flags & NDR_BUFFERS) {
4438                 switch (level) {
4439                         case 1:
4440                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4441                         break;
4442
4443                         default:
4444                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4445                 }
4446         }
4447         return NDR_ERR_SUCCESS;
4448 }
4449
4450 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaDelRequest *r)
4451 {
4452         int level;
4453         level = ndr_print_get_switch_value(ndr, r);
4454         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaDelRequest");
4455         switch (level) {
4456                 case 1:
4457                         ndr_print_drsuapi_DsReplicaDelRequest1(ndr, "req1", &r->req1);
4458                 break;
4459
4460                 default:
4461                         ndr_print_bad_level(ndr, name, level);
4462         }
4463 }
4464
4465 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaModRequest1 *r)
4466 {
4467         if (ndr_flags & NDR_SCALARS) {
4468                 NDR_CHECK(ndr_push_align(ndr, 5));
4469                 if (r->naming_context == NULL) {
4470                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4471                 }
4472                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4473                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dra));
4474                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dra_address));
4475                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->replica_flags));
4477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->modify_fields));
4478                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4479                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4480         }
4481         if (ndr_flags & NDR_BUFFERS) {
4482                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4483                 if (r->source_dra_address) {
4484                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4485                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4486                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4487                         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));
4488                 }
4489         }
4490         return NDR_ERR_SUCCESS;
4491 }
4492
4493 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaModRequest1 *r)
4494 {
4495         uint32_t _ptr_naming_context;
4496         TALLOC_CTX *_mem_save_naming_context_0;
4497         uint32_t _ptr_source_dra_address;
4498         TALLOC_CTX *_mem_save_source_dra_address_0;
4499         if (ndr_flags & NDR_SCALARS) {
4500                 NDR_CHECK(ndr_pull_align(ndr, 5));
4501                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4502                 if (_ptr_naming_context) {
4503                         NDR_PULL_ALLOC(ndr, r->naming_context);
4504                 } else {
4505                         r->naming_context = NULL;
4506                 }
4507                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dra));
4508                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dra_address));
4509                 if (_ptr_source_dra_address) {
4510                         NDR_PULL_ALLOC(ndr, r->source_dra_address);
4511                 } else {
4512                         r->source_dra_address = NULL;
4513                 }
4514                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->replica_flags));
4516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->modify_fields));
4517                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4518                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4519         }
4520         if (ndr_flags & NDR_BUFFERS) {
4521                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4522                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4523                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4524                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4525                 if (r->source_dra_address) {
4526                         _mem_save_source_dra_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4527                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dra_address, 0);
4528                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dra_address));
4529                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dra_address));
4530                         if (ndr_get_array_length(ndr, &r->source_dra_address) > ndr_get_array_size(ndr, &r->source_dra_address)) {
4531                                 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));
4532                         }
4533                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t)));
4534                         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));
4535                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dra_address_0, 0);
4536                 }
4537         }
4538         return NDR_ERR_SUCCESS;
4539 }
4540
4541 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaModRequest1 *r)
4542 {
4543         ndr_print_struct(ndr, name, "drsuapi_DsReplicaModRequest1");
4544         ndr->depth++;
4545         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4546         ndr->depth++;
4547         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4548         ndr->depth--;
4549         ndr_print_GUID(ndr, "source_dra", &r->source_dra);
4550         ndr_print_ptr(ndr, "source_dra_address", r->source_dra_address);
4551         ndr->depth++;
4552         if (r->source_dra_address) {
4553                 ndr_print_string(ndr, "source_dra_address", r->source_dra_address);
4554         }
4555         ndr->depth--;
4556         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4557         ndr_print_uint32(ndr, "replica_flags", r->replica_flags);
4558         ndr_print_uint32(ndr, "modify_fields", r->modify_fields);
4559         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4560         ndr->depth--;
4561 }
4562
4563 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaModRequest *r)
4564 {
4565         if (ndr_flags & NDR_SCALARS) {
4566                 int level = ndr_push_get_switch_value(ndr, r);
4567                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4568                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4569                 switch (level) {
4570                         case 1: {
4571                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4572                         break; }
4573
4574                         default:
4575                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4576                 }
4577         }
4578         if (ndr_flags & NDR_BUFFERS) {
4579                 int level = ndr_push_get_switch_value(ndr, r);
4580                 switch (level) {
4581                         case 1:
4582                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4583                         break;
4584
4585                         default:
4586                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4587                 }
4588         }
4589         return NDR_ERR_SUCCESS;
4590 }
4591
4592 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaModRequest *r)
4593 {
4594         int level;
4595         int32_t _level;
4596         level = ndr_pull_get_switch_value(ndr, r);
4597         if (ndr_flags & NDR_SCALARS) {
4598                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4599                 if (_level != level) {
4600                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4601                 }
4602                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4603                 switch (level) {
4604                         case 1: {
4605                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4606                         break; }
4607
4608                         default:
4609                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4610                 }
4611         }
4612         if (ndr_flags & NDR_BUFFERS) {
4613                 switch (level) {
4614                         case 1:
4615                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4616                         break;
4617
4618                         default:
4619                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4620                 }
4621         }
4622         return NDR_ERR_SUCCESS;
4623 }
4624
4625 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaModRequest *r)
4626 {
4627         int level;
4628         level = ndr_print_get_switch_value(ndr, r);
4629         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaModRequest");
4630         switch (level) {
4631                 case 1:
4632                         ndr_print_drsuapi_DsReplicaModRequest1(ndr, "req1", &r->req1);
4633                 break;
4634
4635                 default:
4636                         ndr_print_bad_level(ndr, name, level);
4637         }
4638 }
4639
4640 static enum ndr_err_code ndr_push_drsuapi_DsMembershipType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsMembershipType r)
4641 {
4642         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
4643         return NDR_ERR_SUCCESS;
4644 }
4645
4646 static enum ndr_err_code ndr_pull_drsuapi_DsMembershipType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsMembershipType *r)
4647 {
4648         uint32_t v;
4649         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
4650         *r = v;
4651         return NDR_ERR_SUCCESS;
4652 }
4653
4654 _PUBLIC_ void ndr_print_drsuapi_DsMembershipType(struct ndr_print *ndr, const char *name, enum drsuapi_DsMembershipType r)
4655 {
4656         const char *val = NULL;
4657
4658         switch (r) {
4659                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS"; break;
4660                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS"; break;
4661                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS"; break;
4662                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2"; break;
4663                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS"; break;
4664                 case DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS"; break;
4665                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2"; break;
4666         }
4667         ndr_print_enum(ndr, name, "ENUM", val, r);
4668 }
4669
4670 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsCtr1 *r)
4671 {
4672         uint32_t cntr_info_array_1;
4673         uint32_t cntr_group_attrs_1;
4674         uint32_t cntr_sids_1;
4675         if (ndr_flags & NDR_SCALARS) {
4676                 NDR_CHECK(ndr_push_align(ndr, 5));
4677                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
4678                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
4679                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
4680                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_attrs));
4682                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
4683                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4684         }
4685         if (ndr_flags & NDR_BUFFERS) {
4686                 if (r->info_array) {
4687                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4688                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4689                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4690                         }
4691                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4692                                 if (r->info_array[cntr_info_array_1]) {
4693                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4694                                 }
4695                         }
4696                 }
4697                 if (r->group_attrs) {
4698                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4699                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4700                                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->group_attrs[cntr_group_attrs_1]));
4701                         }
4702                 }
4703                 if (r->sids) {
4704                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_sids));
4705                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4706                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_1]));
4707                         }
4708                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4709                                 if (r->sids[cntr_sids_1]) {
4710                                         NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4711                                 }
4712                         }
4713                 }
4714         }
4715         return NDR_ERR_SUCCESS;
4716 }
4717
4718 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsCtr1 *r)
4719 {
4720         uint32_t _ptr_info_array;
4721         uint32_t cntr_info_array_1;
4722         TALLOC_CTX *_mem_save_info_array_0;
4723         TALLOC_CTX *_mem_save_info_array_1;
4724         TALLOC_CTX *_mem_save_info_array_2;
4725         uint32_t _ptr_group_attrs;
4726         uint32_t cntr_group_attrs_1;
4727         TALLOC_CTX *_mem_save_group_attrs_0;
4728         TALLOC_CTX *_mem_save_group_attrs_1;
4729         uint32_t _ptr_sids;
4730         uint32_t cntr_sids_1;
4731         TALLOC_CTX *_mem_save_sids_0;
4732         TALLOC_CTX *_mem_save_sids_1;
4733         TALLOC_CTX *_mem_save_sids_2;
4734         if (ndr_flags & NDR_SCALARS) {
4735                 NDR_CHECK(ndr_pull_align(ndr, 5));
4736                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
4737                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_memberships));
4738                 if (r->num_memberships > 10000) {
4739                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4740                 }
4741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
4742                 if (r->num_sids > 10000) {
4743                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4744                 }
4745                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4746                 if (_ptr_info_array) {
4747                         NDR_PULL_ALLOC(ndr, r->info_array);
4748                 } else {
4749                         r->info_array = NULL;
4750                 }
4751                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_attrs));
4752                 if (_ptr_group_attrs) {
4753                         NDR_PULL_ALLOC(ndr, r->group_attrs);
4754                 } else {
4755                         r->group_attrs = NULL;
4756                 }
4757                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4758                 if (_ptr_sids) {
4759                         NDR_PULL_ALLOC(ndr, r->sids);
4760                 } else {
4761                         r->sids = NULL;
4762                 }
4763                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4764         }
4765         if (ndr_flags & NDR_BUFFERS) {
4766                 if (r->info_array) {
4767                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4768                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4769                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4770                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
4771                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4772                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4773                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4774                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4775                                 if (_ptr_info_array) {
4776                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4777                                 } else {
4778                                         r->info_array[cntr_info_array_1] = NULL;
4779                                 }
4780                         }
4781                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4782                                 if (r->info_array[cntr_info_array_1]) {
4783                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4784                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4785                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4786                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
4787                                 }
4788                         }
4789                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
4790                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
4791                 }
4792                 if (r->group_attrs) {
4793                         _mem_save_group_attrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
4794                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4795                         NDR_CHECK(ndr_pull_array_size(ndr, &r->group_attrs));
4796                         NDR_PULL_ALLOC_N(ndr, r->group_attrs, ndr_get_array_size(ndr, &r->group_attrs));
4797                         _mem_save_group_attrs_1 = NDR_PULL_GET_MEM_CTX(ndr);
4798                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4799                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4800                                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->group_attrs[cntr_group_attrs_1]));
4801                         }
4802                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_1, 0);
4803                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_0, 0);
4804                 }
4805                 if (r->sids) {
4806                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4807                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4808                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4809                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4810                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4811                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4812                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4813                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4814                                 if (_ptr_sids) {
4815                                         NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_1]);
4816                                 } else {
4817                                         r->sids[cntr_sids_1] = NULL;
4818                                 }
4819                         }
4820                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4821                                 if (r->sids[cntr_sids_1]) {
4822                                         _mem_save_sids_2 = NDR_PULL_GET_MEM_CTX(ndr);
4823                                         NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_1], 0);
4824                                         NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4825                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_2, 0);
4826                                 }
4827                         }
4828                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
4829                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
4830                 }
4831                 if (r->info_array) {
4832                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->num_memberships));
4833                 }
4834                 if (r->group_attrs) {
4835                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->group_attrs, r->num_memberships));
4836                 }
4837                 if (r->sids) {
4838                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
4839                 }
4840         }
4841         return NDR_ERR_SUCCESS;
4842 }
4843
4844 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsCtr1 *r)
4845 {
4846         uint32_t cntr_info_array_1;
4847         uint32_t cntr_group_attrs_1;
4848         uint32_t cntr_sids_1;
4849         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsCtr1");
4850         ndr->depth++;
4851         ndr_print_NTSTATUS(ndr, "status", r->status);
4852         ndr_print_uint32(ndr, "num_memberships", r->num_memberships);
4853         ndr_print_uint32(ndr, "num_sids", r->num_sids);
4854         ndr_print_ptr(ndr, "info_array", r->info_array);
4855         ndr->depth++;
4856         if (r->info_array) {
4857                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->num_memberships);
4858                 ndr->depth++;
4859                 for (cntr_info_array_1=0;cntr_info_array_1<r->num_memberships;cntr_info_array_1++) {
4860                         char *idx_1=NULL;
4861                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
4862                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
4863                                 ndr->depth++;
4864                                 if (r->info_array[cntr_info_array_1]) {
4865                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
4866                                 }
4867                                 ndr->depth--;
4868                                 free(idx_1);
4869                         }
4870                 }
4871                 ndr->depth--;
4872         }
4873         ndr->depth--;
4874         ndr_print_ptr(ndr, "group_attrs", r->group_attrs);
4875         ndr->depth++;
4876         if (r->group_attrs) {
4877                 ndr->print(ndr, "%s: ARRAY(%d)", "group_attrs", (int)r->num_memberships);
4878                 ndr->depth++;
4879                 for (cntr_group_attrs_1=0;cntr_group_attrs_1<r->num_memberships;cntr_group_attrs_1++) {
4880                         char *idx_1=NULL;
4881                         if (asprintf(&idx_1, "[%d]", cntr_group_attrs_1) != -1) {
4882                                 ndr_print_samr_GroupAttrs(ndr, "group_attrs", r->group_attrs[cntr_group_attrs_1]);
4883                                 free(idx_1);
4884                         }
4885                 }
4886                 ndr->depth--;
4887         }
4888         ndr->depth--;
4889         ndr_print_ptr(ndr, "sids", r->sids);
4890         ndr->depth++;
4891         if (r->sids) {
4892                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
4893                 ndr->depth++;
4894                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
4895                         char *idx_1=NULL;
4896                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4897                                 ndr_print_ptr(ndr, "sids", r->sids[cntr_sids_1]);
4898                                 ndr->depth++;
4899                                 if (r->sids[cntr_sids_1]) {
4900                                         ndr_print_dom_sid28(ndr, "sids", r->sids[cntr_sids_1]);
4901                                 }
4902                                 ndr->depth--;
4903                                 free(idx_1);
4904                         }
4905                 }
4906                 ndr->depth--;
4907         }
4908         ndr->depth--;
4909         ndr->depth--;
4910 }
4911
4912 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsCtr *r)
4913 {
4914         if (ndr_flags & NDR_SCALARS) {
4915                 int level = ndr_push_get_switch_value(ndr, r);
4916                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4917                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4918                 switch (level) {
4919                         case 1: {
4920                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4921                         break; }
4922
4923                         default:
4924                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4925                 }
4926         }
4927         if (ndr_flags & NDR_BUFFERS) {
4928                 int level = ndr_push_get_switch_value(ndr, r);
4929                 switch (level) {
4930                         case 1:
4931                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4932                         break;
4933
4934                         default:
4935                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4936                 }
4937         }
4938         return NDR_ERR_SUCCESS;
4939 }
4940
4941 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsCtr *r)
4942 {
4943         int level;
4944         int32_t _level;
4945         level = ndr_pull_get_switch_value(ndr, r);
4946         if (ndr_flags & NDR_SCALARS) {
4947                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4948                 if (_level != level) {
4949                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4950                 }
4951                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4952                 switch (level) {
4953                         case 1: {
4954                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4955                         break; }
4956
4957                         default:
4958                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4959                 }
4960         }
4961         if (ndr_flags & NDR_BUFFERS) {
4962                 switch (level) {
4963                         case 1:
4964                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4965                         break;
4966
4967                         default:
4968                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4969                 }
4970         }
4971         return NDR_ERR_SUCCESS;
4972 }
4973
4974 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsCtr *r)
4975 {
4976         int level;
4977         level = ndr_print_get_switch_value(ndr, r);
4978         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsCtr");
4979         switch (level) {
4980                 case 1:
4981                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
4982                 break;
4983
4984                 default:
4985                         ndr_print_bad_level(ndr, name, level);
4986         }
4987 }
4988
4989 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsRequest1 *r)
4990 {
4991         uint32_t cntr_info_array_1;
4992         if (ndr_flags & NDR_SCALARS) {
4993                 NDR_CHECK(ndr_push_align(ndr, 5));
4994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4995                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
4997                 NDR_CHECK(ndr_push_drsuapi_DsMembershipType(ndr, NDR_SCALARS, r->type));
4998                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
4999                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5000         }
5001         if (ndr_flags & NDR_BUFFERS) {
5002                 if (r->info_array) {
5003                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5004                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5005                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
5006                         }
5007                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5008                                 if (r->info_array[cntr_info_array_1]) {
5009                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5010                                 }
5011                         }
5012                 }
5013                 if (r->domain) {
5014                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5015                 }
5016         }
5017         return NDR_ERR_SUCCESS;
5018 }
5019
5020 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsRequest1 *r)
5021 {
5022         uint32_t _ptr_info_array;
5023         uint32_t cntr_info_array_1;
5024         TALLOC_CTX *_mem_save_info_array_0;
5025         TALLOC_CTX *_mem_save_info_array_1;
5026         TALLOC_CTX *_mem_save_info_array_2;
5027         uint32_t _ptr_domain;
5028         TALLOC_CTX *_mem_save_domain_0;
5029         if (ndr_flags & NDR_SCALARS) {
5030                 NDR_CHECK(ndr_pull_align(ndr, 5));
5031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5032                 if (r->count < 1 || r->count > 10000) {
5033                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5034                 }
5035                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5036                 if (_ptr_info_array) {
5037                         NDR_PULL_ALLOC(ndr, r->info_array);
5038                 } else {
5039                         r->info_array = NULL;
5040                 }
5041                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
5042                 NDR_CHECK(ndr_pull_drsuapi_DsMembershipType(ndr, NDR_SCALARS, &r->type));
5043                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
5044                 if (_ptr_domain) {
5045                         NDR_PULL_ALLOC(ndr, r->domain);
5046                 } else {
5047                         r->domain = NULL;
5048                 }
5049                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5050         }
5051         if (ndr_flags & NDR_BUFFERS) {
5052                 if (r->info_array) {
5053                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5054                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5055                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
5056                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
5057                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5058                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5059                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5060                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5061                                 if (_ptr_info_array) {
5062                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
5063                                 } else {
5064                                         r->info_array[cntr_info_array_1] = NULL;
5065                                 }
5066                         }
5067                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5068                                 if (r->info_array[cntr_info_array_1]) {
5069                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
5070                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
5071                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5072                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
5073                                 }
5074                         }
5075                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
5076                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
5077                 }
5078                 if (r->domain) {
5079                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
5080                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
5081                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5082                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
5083                 }
5084                 if (r->info_array) {
5085                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->count));
5086                 }
5087         }
5088         return NDR_ERR_SUCCESS;
5089 }
5090
5091 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsRequest1 *r)
5092 {
5093         uint32_t cntr_info_array_1;
5094         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsRequest1");
5095         ndr->depth++;
5096         ndr_print_uint32(ndr, "count", r->count);
5097         ndr_print_ptr(ndr, "info_array", r->info_array);
5098         ndr->depth++;
5099         if (r->info_array) {
5100                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->count);
5101                 ndr->depth++;
5102                 for (cntr_info_array_1=0;cntr_info_array_1<r->count;cntr_info_array_1++) {
5103                         char *idx_1=NULL;
5104                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
5105                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
5106                                 ndr->depth++;
5107                                 if (r->info_array[cntr_info_array_1]) {
5108                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
5109                                 }
5110                                 ndr->depth--;
5111                                 free(idx_1);
5112                         }
5113                 }
5114                 ndr->depth--;
5115         }
5116         ndr->depth--;
5117         ndr_print_uint32(ndr, "flags", r->flags);
5118         ndr_print_drsuapi_DsMembershipType(ndr, "type", r->type);
5119         ndr_print_ptr(ndr, "domain", r->domain);
5120         ndr->depth++;
5121         if (r->domain) {
5122                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "domain", r->domain);
5123         }
5124         ndr->depth--;
5125         ndr->depth--;
5126 }
5127
5128 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsRequest *r)
5129 {
5130         if (ndr_flags & NDR_SCALARS) {
5131                 int level = ndr_push_get_switch_value(ndr, r);
5132                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5133                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5134                 switch (level) {
5135                         case 1: {
5136                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5137                         break; }
5138
5139                         default:
5140                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5141                 }
5142         }
5143         if (ndr_flags & NDR_BUFFERS) {
5144                 int level = ndr_push_get_switch_value(ndr, r);
5145                 switch (level) {
5146                         case 1:
5147                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5148                         break;
5149
5150                         default:
5151                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5152                 }
5153         }
5154         return NDR_ERR_SUCCESS;
5155 }
5156
5157 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsRequest *r)
5158 {
5159         int level;
5160         int32_t _level;
5161         level = ndr_pull_get_switch_value(ndr, r);
5162         if (ndr_flags & NDR_SCALARS) {
5163                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5164                 if (_level != level) {
5165                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5166                 }
5167                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5168                 switch (level) {
5169                         case 1: {
5170                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5171                         break; }
5172
5173                         default:
5174                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5175                 }
5176         }
5177         if (ndr_flags & NDR_BUFFERS) {
5178                 switch (level) {
5179                         case 1:
5180                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5181                         break;
5182
5183                         default:
5184                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5185                 }
5186         }
5187         return NDR_ERR_SUCCESS;
5188 }
5189
5190 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsRequest *r)
5191 {
5192         int level;
5193         level = ndr_print_get_switch_value(ndr, r);
5194         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsRequest");
5195         switch (level) {
5196                 case 1:
5197                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req1", &r->req1);
5198                 break;
5199
5200                 default:
5201                         ndr_print_bad_level(ndr, name, level);
5202         }
5203 }
5204
5205 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5206 {
5207         if (ndr_flags & NDR_SCALARS) {
5208                 NDR_CHECK(ndr_push_align(ndr, 5));
5209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
5210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
5211                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
5212                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
5213                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5214         }
5215         if (ndr_flags & NDR_BUFFERS) {
5216                 if (r->data) {
5217                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
5218                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
5219                 }
5220         }
5221         return NDR_ERR_SUCCESS;
5222 }
5223
5224 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5225 {
5226         uint32_t _ptr_data;
5227         TALLOC_CTX *_mem_save_data_0;
5228         if (ndr_flags & NDR_SCALARS) {
5229                 NDR_CHECK(ndr_pull_align(ndr, 5));
5230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
5231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
5232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
5233                 if (r->length > 0x00A00000) {
5234                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5235                 }
5236                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
5237                 if (_ptr_data) {
5238                         NDR_PULL_ALLOC(ndr, r->data);
5239                 } else {
5240                         r->data = NULL;
5241                 }
5242                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5243         }
5244         if (ndr_flags & NDR_BUFFERS) {
5245                 if (r->data) {
5246                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5247                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
5248                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
5249                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
5250                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
5251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
5252                 }
5253                 if (r->data) {
5254                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
5255                 }
5256         }
5257         return NDR_ERR_SUCCESS;
5258 }
5259
5260 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5261 {
5262         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogRequest1");
5263         ndr->depth++;
5264         ndr_print_uint32(ndr, "unknown1", r->unknown1);
5265         ndr_print_uint32(ndr, "unknown2", r->unknown2);
5266         ndr_print_uint32(ndr, "length", r->length);
5267         ndr_print_ptr(ndr, "data", r->data);
5268         ndr->depth++;
5269         if (r->data) {
5270                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
5271         }
5272         ndr->depth--;
5273         ndr->depth--;
5274 }
5275
5276 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5277 {
5278         if (ndr_flags & NDR_SCALARS) {
5279                 int level = ndr_push_get_switch_value(ndr, r);
5280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5281                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5282                 switch (level) {
5283                         case 1: {
5284                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5285                         break; }
5286
5287                         default:
5288                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5289                 }
5290         }
5291         if (ndr_flags & NDR_BUFFERS) {
5292                 int level = ndr_push_get_switch_value(ndr, r);
5293                 switch (level) {
5294                         case 1:
5295                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5296                         break;
5297
5298                         default:
5299                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5300                 }
5301         }
5302         return NDR_ERR_SUCCESS;
5303 }
5304
5305 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogRequest *r)
5306 {
5307         int level;
5308         uint32_t _level;
5309         level = ndr_pull_get_switch_value(ndr, r);
5310         if (ndr_flags & NDR_SCALARS) {
5311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5312                 if (_level != level) {
5313                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5314                 }
5315                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5316                 switch (level) {
5317                         case 1: {
5318                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5319                         break; }
5320
5321                         default:
5322                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5323                 }
5324         }
5325         if (ndr_flags & NDR_BUFFERS) {
5326                 switch (level) {
5327                         case 1:
5328                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5329                         break;
5330
5331                         default:
5332                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5333                 }
5334         }
5335         return NDR_ERR_SUCCESS;
5336 }
5337
5338 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5339 {
5340         int level;
5341         level = ndr_print_get_switch_value(ndr, r);
5342         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogRequest");
5343         switch (level) {
5344                 case 1:
5345                         ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(ndr, "req1", &r->req1);
5346                 break;
5347
5348                 default:
5349                         ndr_print_bad_level(ndr, name, level);
5350         }
5351 }
5352
5353 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5354 {
5355         if (ndr_flags & NDR_SCALARS) {
5356                 NDR_CHECK(ndr_push_align(ndr, 8));
5357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
5358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
5359                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5360                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time2));
5361                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5362                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time4));
5363                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5364                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time6));
5365                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
5366                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data1));
5367                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data2));
5368                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5369         }
5370         if (ndr_flags & NDR_BUFFERS) {
5371                 if (r->data1) {
5372                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length1));
5373                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data1, r->length1));
5374                 }
5375                 if (r->data2) {
5376                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length2));
5377                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data2, r->length2));
5378                 }
5379         }
5380         return NDR_ERR_SUCCESS;
5381 }
5382
5383 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5384 {
5385         uint32_t _ptr_data1;
5386         TALLOC_CTX *_mem_save_data1_0;
5387         uint32_t _ptr_data2;
5388         TALLOC_CTX *_mem_save_data2_0;
5389         if (ndr_flags & NDR_SCALARS) {
5390                 NDR_CHECK(ndr_pull_align(ndr, 8));
5391                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length1));
5392                 if (r->length1 > 0x00A00000) {
5393                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5394                 }
5395                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length2));
5396                 if (r->length2 > 0x00A00000) {
5397                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5398                 }
5399                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5400                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time2));
5401                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5402                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time4));
5403                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5404                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time6));
5405                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
5406                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data1));
5407                 if (_ptr_data1) {
5408                         NDR_PULL_ALLOC(ndr, r->data1);
5409                 } else {
5410                         r->data1 = NULL;
5411                 }
5412                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data2));
5413                 if (_ptr_data2) {
5414                         NDR_PULL_ALLOC(ndr, r->data2);
5415                 } else {
5416                         r->data2 = NULL;
5417                 }
5418                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5419         }
5420         if (ndr_flags & NDR_BUFFERS) {
5421                 if (r->data1) {
5422                         _mem_save_data1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5423                         NDR_PULL_SET_MEM_CTX(ndr, r->data1, 0);
5424                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data1));
5425                         NDR_PULL_ALLOC_N(ndr, r->data1, ndr_get_array_size(ndr, &r->data1));
5426                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data1, ndr_get_array_size(ndr, &r->data1)));
5427                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data1_0, 0);
5428                 }
5429                 if (r->data2) {
5430                         _mem_save_data2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5431                         NDR_PULL_SET_MEM_CTX(ndr, r->data2, 0);
5432                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data2));
5433                         NDR_PULL_ALLOC_N(ndr, r->data2, ndr_get_array_size(ndr, &r->data2));
5434                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data2, ndr_get_array_size(ndr, &r->data2)));
5435                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data2_0, 0);
5436                 }
5437                 if (r->data1) {
5438                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data1, r->length1));
5439                 }
5440                 if (r->data2) {
5441                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data2, r->length2));
5442                 }
5443         }
5444         return NDR_ERR_SUCCESS;
5445 }
5446
5447 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5448 {
5449         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogInfo1");
5450         ndr->depth++;
5451         ndr_print_uint32(ndr, "length1", r->length1);
5452         ndr_print_uint32(ndr, "length2", r->length2);
5453         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5454         ndr_print_NTTIME(ndr, "time2", r->time2);
5455         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5456         ndr_print_NTTIME(ndr, "time4", r->time4);
5457         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5458         ndr_print_NTTIME(ndr, "time6", r->time6);
5459         ndr_print_NTSTATUS(ndr, "status", r->status);
5460         ndr_print_ptr(ndr, "data1", r->data1);
5461         ndr->depth++;
5462         if (r->data1) {
5463                 ndr_print_array_uint8(ndr, "data1", r->data1, r->length1);
5464         }
5465         ndr->depth--;
5466         ndr_print_ptr(ndr, "data2", r->data2);
5467         ndr->depth++;
5468         if (r->data2) {
5469                 ndr_print_array_uint8(ndr, "data2", r->data2, r->length2);
5470         }
5471         ndr->depth--;
5472         ndr->depth--;
5473 }
5474
5475 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5476 {
5477         if (ndr_flags & NDR_SCALARS) {
5478                 int level = ndr_push_get_switch_value(ndr, r);
5479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5480                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5481                 switch (level) {
5482                         case 1: {
5483                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5484                         break; }
5485
5486                         default:
5487                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5488                 }
5489         }
5490         if (ndr_flags & NDR_BUFFERS) {
5491                 int level = ndr_push_get_switch_value(ndr, r);
5492                 switch (level) {
5493                         case 1:
5494                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5495                         break;
5496
5497                         default:
5498                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5499                 }
5500         }
5501         return NDR_ERR_SUCCESS;
5502 }
5503
5504 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogInfo *r)
5505 {
5506         int level;
5507         uint32_t _level;
5508         level = ndr_pull_get_switch_value(ndr, r);
5509         if (ndr_flags & NDR_SCALARS) {
5510                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5511                 if (_level != level) {
5512                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5513                 }
5514                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5515                 switch (level) {
5516                         case 1: {
5517                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5518                         break; }
5519
5520                         default:
5521                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5522                 }
5523         }
5524         if (ndr_flags & NDR_BUFFERS) {
5525                 switch (level) {
5526                         case 1:
5527                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5528                         break;
5529
5530                         default:
5531                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5532                 }
5533         }
5534         return NDR_ERR_SUCCESS;
5535 }
5536
5537 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5538 {
5539         int level;
5540         level = ndr_print_get_switch_value(ndr, r);
5541         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogInfo");
5542         switch (level) {
5543                 case 1:
5544                         ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(ndr, "info1", &r->info1);
5545                 break;
5546
5547                 default:
5548                         ndr_print_bad_level(ndr, name, level);
5549         }
5550 }
5551
5552 static enum ndr_err_code ndr_push_drsuapi_DsNameStatus(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameStatus r)
5553 {
5554         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5555         return NDR_ERR_SUCCESS;
5556 }
5557
5558 static enum ndr_err_code ndr_pull_drsuapi_DsNameStatus(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameStatus *r)
5559 {
5560         uint32_t v;
5561         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5562         *r = v;
5563         return NDR_ERR_SUCCESS;
5564 }
5565
5566 _PUBLIC_ void ndr_print_drsuapi_DsNameStatus(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameStatus r)
5567 {
5568         const char *val = NULL;
5569
5570         switch (r) {
5571                 case DRSUAPI_DS_NAME_STATUS_OK: val = "DRSUAPI_DS_NAME_STATUS_OK"; break;
5572                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR: val = "DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR"; break;
5573                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND: val = "DRSUAPI_DS_NAME_STATUS_NOT_FOUND"; break;
5574                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE: val = "DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE"; break;
5575                 case DRSUAPI_DS_NAME_STATUS_NO_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_MAPPING"; break;
5576                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY: val = "DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY"; break;
5577                 case DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING"; break;
5578                 case DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL"; break;
5579         }
5580         ndr_print_enum(ndr, name, "ENUM", val, r);
5581 }
5582
5583 static enum ndr_err_code ndr_push_drsuapi_DsNameFlags(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFlags r)
5584 {
5585         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5586         return NDR_ERR_SUCCESS;
5587 }
5588
5589 static enum ndr_err_code ndr_pull_drsuapi_DsNameFlags(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFlags *r)
5590 {
5591         uint32_t v;
5592         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5593         *r = v;
5594         return NDR_ERR_SUCCESS;
5595 }
5596
5597 _PUBLIC_ void ndr_print_drsuapi_DsNameFlags(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFlags r)
5598 {
5599         const char *val = NULL;
5600
5601         switch (r) {
5602                 case DRSUAPI_DS_NAME_FLAG_NO_FLAGS: val = "DRSUAPI_DS_NAME_FLAG_NO_FLAGS"; break;
5603                 case DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY: val = "DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY"; break;
5604                 case DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC: val = "DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC"; break;
5605                 case DRSUAPI_DS_NAME_FLAG_GCVERIFY: val = "DRSUAPI_DS_NAME_FLAG_GCVERIFY"; break;
5606                 case DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL"; break;
5607         }
5608         ndr_print_enum(ndr, name, "ENUM", val, r);
5609 }
5610
5611 static enum ndr_err_code ndr_push_drsuapi_DsNameFormat(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFormat r)
5612 {
5613         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5614         return NDR_ERR_SUCCESS;
5615 }
5616
5617 static enum ndr_err_code ndr_pull_drsuapi_DsNameFormat(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFormat *r)
5618 {
5619         uint32_t v;
5620         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5621         *r = v;
5622         return NDR_ERR_SUCCESS;
5623 }
5624
5625 _PUBLIC_ void ndr_print_drsuapi_DsNameFormat(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFormat r)
5626 {
5627         const char *val = NULL;
5628
5629         switch (r) {
5630                 case DRSUAPI_DS_NAME_FORMAT_UNKNOWN: val = "DRSUAPI_DS_NAME_FORMAT_UNKNOWN"; break;
5631                 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: val = "DRSUAPI_DS_NAME_FORMAT_FQDN_1779"; break;
5632                 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: val = "DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT"; break;
5633                 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: val = "DRSUAPI_DS_NAME_FORMAT_DISPLAY"; break;
5634                 case DRSUAPI_DS_NAME_FORMAT_GUID: val = "DRSUAPI_DS_NAME_FORMAT_GUID"; break;
5635                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL"; break;
5636                 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL"; break;
5637                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX"; break;
5638                 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL"; break;
5639                 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: val = "DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY"; break;
5640                 case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: val = "DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN"; break;
5641         }
5642         ndr_print_enum(ndr, name, "ENUM", val, r);
5643 }
5644
5645 static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameString *r)
5646 {
5647         if (ndr_flags & NDR_SCALARS) {
5648                 NDR_CHECK(ndr_push_align(ndr, 5));
5649                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
5650                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5651         }
5652         if (ndr_flags & NDR_BUFFERS) {
5653                 if (r->str) {
5654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5656                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5657                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str, ndr_charset_length(r->str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5658                 }
5659         }
5660         return NDR_ERR_SUCCESS;
5661 }
5662
5663 static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameString *r)
5664 {
5665         uint32_t _ptr_str;
5666         TALLOC_CTX *_mem_save_str_0;
5667         if (ndr_flags & NDR_SCALARS) {
5668                 NDR_CHECK(ndr_pull_align(ndr, 5));
5669                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
5670                 if (_ptr_str) {
5671                         NDR_PULL_ALLOC(ndr, r->str);
5672                 } else {
5673                         r->str = NULL;
5674                 }
5675                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5676         }
5677         if (ndr_flags & NDR_BUFFERS) {
5678                 if (r->str) {
5679                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
5680                         NDR_PULL_SET_MEM_CTX(ndr, r->str, 0);
5681                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str));
5682                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str));
5683                         if (ndr_get_array_length(ndr, &r->str) > ndr_get_array_size(ndr, &r->str)) {
5684                                 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));
5685                         }
5686                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t)));
5687                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t), CH_UTF16));
5688                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
5689                 }
5690         }
5691         return NDR_ERR_SUCCESS;
5692 }
5693
5694 _PUBLIC_ void ndr_print_drsuapi_DsNameString(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameString *r)
5695 {
5696         ndr_print_struct(ndr, name, "drsuapi_DsNameString");
5697         ndr->depth++;
5698         ndr_print_ptr(ndr, "str", r->str);
5699         ndr->depth++;
5700         if (r->str) {
5701                 ndr_print_string(ndr, "str", r->str);
5702         }
5703         ndr->depth--;
5704         ndr->depth--;
5705 }
5706
5707 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameRequest1 *r)
5708 {
5709         uint32_t cntr_names_1;
5710         if (ndr_flags & NDR_SCALARS) {
5711                 NDR_CHECK(ndr_push_align(ndr, 5));
5712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->codepage));
5713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->language));
5714                 NDR_CHECK(ndr_push_drsuapi_DsNameFlags(ndr, NDR_SCALARS, r->format_flags));
5715                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_offered));
5716                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
5717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5718                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
5719                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5720         }
5721         if (ndr_flags & NDR_BUFFERS) {
5722                 if (r->names) {
5723                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5724                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5725                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5726                         }
5727                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5728                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5729                         }
5730                 }
5731         }
5732         return NDR_ERR_SUCCESS;
5733 }
5734
5735 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameRequest1 *r)
5736 {
5737         uint32_t _ptr_names;
5738         uint32_t cntr_names_1;
5739         TALLOC_CTX *_mem_save_names_0;
5740         TALLOC_CTX *_mem_save_names_1;
5741         if (ndr_flags & NDR_SCALARS) {
5742                 NDR_CHECK(ndr_pull_align(ndr, 5));
5743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->codepage));
5744                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->language));
5745                 NDR_CHECK(ndr_pull_drsuapi_DsNameFlags(ndr, NDR_SCALARS, &r->format_flags));
5746                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_offered));
5747                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_desired));
5748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5749                 if (r->count < 1 || r->count > 10000) {
5750                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5751                 }
5752                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
5753                 if (_ptr_names) {
5754                         NDR_PULL_ALLOC(ndr, r->names);
5755                 } else {
5756                         r->names = NULL;
5757                 }
5758                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5759         }
5760         if (ndr_flags & NDR_BUFFERS) {
5761                 if (r->names) {
5762                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5763                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5764                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
5765                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
5766                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
5767                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5768                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5769                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5770                         }
5771                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5772                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5773                         }
5774                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
5775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
5776                 }
5777                 if (r->names) {
5778                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
5779                 }
5780         }
5781         return NDR_ERR_SUCCESS;
5782 }
5783
5784 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameRequest1 *r)
5785 {
5786         uint32_t cntr_names_1;
5787         ndr_print_struct(ndr, name, "drsuapi_DsNameRequest1");
5788         ndr->depth++;
5789         ndr_print_uint32(ndr, "codepage", r->codepage);
5790         ndr_print_uint32(ndr, "language", r->language);
5791         ndr_print_drsuapi_DsNameFlags(ndr, "format_flags", r->format_flags);
5792         ndr_print_drsuapi_DsNameFormat(ndr, "format_offered", r->format_offered);
5793         ndr_print_drsuapi_DsNameFormat(ndr, "format_desired", r->format_desired);
5794         ndr_print_uint32(ndr, "count", r->count);
5795         ndr_print_ptr(ndr, "names", r->names);
5796         ndr->depth++;
5797         if (r->names) {
5798                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
5799                 ndr->depth++;
5800                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
5801                         char *idx_1=NULL;
5802                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
5803                                 ndr_print_drsuapi_DsNameString(ndr, "names", &r->names[cntr_names_1]);
5804                                 free(idx_1);
5805                         }
5806                 }
5807                 ndr->depth--;
5808         }
5809         ndr->depth--;
5810         ndr->depth--;
5811 }
5812
5813 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameRequest *r)
5814 {
5815         if (ndr_flags & NDR_SCALARS) {
5816                 int level = ndr_push_get_switch_value(ndr, r);
5817                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5818                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5819                 switch (level) {
5820                         case 1: {
5821                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5822                         break; }
5823
5824                         default:
5825                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5826                 }
5827         }
5828         if (ndr_flags & NDR_BUFFERS) {
5829                 int level = ndr_push_get_switch_value(ndr, r);
5830                 switch (level) {
5831                         case 1:
5832                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5833                         break;
5834
5835                         default:
5836                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5837                 }
5838         }
5839         return NDR_ERR_SUCCESS;
5840 }
5841
5842 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameRequest *r)
5843 {
5844         int level;
5845         int32_t _level;
5846         level = ndr_pull_get_switch_value(ndr, r);
5847         if (ndr_flags & NDR_SCALARS) {
5848                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5849                 if (_level != level) {
5850                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5851                 }
5852                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5853                 switch (level) {
5854                         case 1: {
5855                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5856                         break; }
5857
5858                         default:
5859                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5860                 }
5861         }
5862         if (ndr_flags & NDR_BUFFERS) {
5863                 switch (level) {
5864                         case 1:
5865                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5866                         break;
5867
5868                         default:
5869                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5870                 }
5871         }
5872         return NDR_ERR_SUCCESS;
5873 }
5874
5875 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameRequest *r)
5876 {
5877         int level;
5878         level = ndr_print_get_switch_value(ndr, r);
5879         ndr_print_union(ndr, name, level, "drsuapi_DsNameRequest");
5880         switch (level) {
5881                 case 1:
5882                         ndr_print_drsuapi_DsNameRequest1(ndr, "req1", &r->req1);
5883                 break;
5884
5885                 default:
5886                         ndr_print_bad_level(ndr, name, level);
5887         }
5888 }
5889
5890 static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameInfo1 *r)
5891 {
5892         if (ndr_flags & NDR_SCALARS) {
5893                 NDR_CHECK(ndr_push_align(ndr, 5));
5894                 NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
5895                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
5896                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
5897                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5898         }
5899         if (ndr_flags & NDR_BUFFERS) {
5900                 if (r->dns_domain_name) {
5901                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5902                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5903                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5904                         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));
5905                 }
5906                 if (r->result_name) {
5907                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5908                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5909                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5910                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->result_name, ndr_charset_length(r->result_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5911                 }
5912         }
5913         return NDR_ERR_SUCCESS;
5914 }
5915
5916 static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameInfo1 *r)
5917 {
5918         uint32_t _ptr_dns_domain_name;
5919         TALLOC_CTX *_mem_save_dns_domain_name_0;
5920         uint32_t _ptr_result_name;
5921         TALLOC_CTX *_mem_save_result_name_0;
5922         if (ndr_flags & NDR_SCALARS) {
5923                 NDR_CHECK(ndr_pull_align(ndr, 5));
5924                 NDR_CHECK(ndr_pull_drsuapi_DsNameStatus(ndr, NDR_SCALARS, &r->status));
5925                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain_name));
5926                 if (_ptr_dns_domain_name) {
5927                         NDR_PULL_ALLOC(ndr, r->dns_domain_name);
5928                 } else {
5929                         r->dns_domain_name = NULL;
5930                 }
5931                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_result_name));
5932                 if (_ptr_result_name) {
5933                         NDR_PULL_ALLOC(ndr, r->result_name);
5934                 } else {
5935                         r->result_name = NULL;
5936                 }
5937                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5938         }
5939         if (ndr_flags & NDR_BUFFERS) {
5940                 if (r->dns_domain_name) {
5941                         _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5942                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
5943                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain_name));
5944                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain_name));
5945                         if (ndr_get_array_length(ndr, &r->dns_domain_name) > ndr_get_array_size(ndr, &r->dns_domain_name)) {
5946                                 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));
5947                         }
5948                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t)));
5949                         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));
5950                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
5951                 }
5952                 if (r->result_name) {
5953                         _mem_save_result_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5954                         NDR_PULL_SET_MEM_CTX(ndr, r->result_name, 0);
5955                         NDR_CHECK(ndr_pull_array_size(ndr, &r->result_name));
5956                         NDR_CHECK(ndr_pull_array_length(ndr, &r->result_name));
5957                         if (ndr_get_array_length(ndr, &r->result_name) > ndr_get_array_size(ndr, &r->result_name)) {
5958                                 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));
5959                         }
5960                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t)));
5961                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t), CH_UTF16));
5962                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_result_name_0, 0);
5963                 }
5964         }
5965         return NDR_ERR_SUCCESS;
5966 }
5967
5968 _PUBLIC_ void ndr_print_drsuapi_DsNameInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameInfo1 *r)
5969 {
5970         ndr_print_struct(ndr, name, "drsuapi_DsNameInfo1");
5971         ndr->depth++;
5972         ndr_print_drsuapi_DsNameStatus(ndr, "status", r->status);
5973         ndr_print_ptr(ndr, "dns_domain_name", r->dns_domain_name);
5974         ndr->depth++;
5975         if (r->dns_domain_name) {
5976                 ndr_print_string(ndr, "dns_domain_name", r->dns_domain_name);
5977         }
5978         ndr->depth--;
5979         ndr_print_ptr(ndr, "result_name", r->result_name);
5980         ndr->depth++;
5981         if (r->result_name) {
5982                 ndr_print_string(ndr, "result_name", r->result_name);
5983         }
5984         ndr->depth--;
5985         ndr->depth--;
5986 }
5987
5988 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameCtr1 *r)
5989 {
5990         uint32_t cntr_array_1;
5991         if (ndr_flags & NDR_SCALARS) {
5992                 NDR_CHECK(ndr_push_align(ndr, 5));
5993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5994                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5995                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5996         }
5997         if (ndr_flags & NDR_BUFFERS) {
5998                 if (r->array) {
5999                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6000                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6001                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6002                         }
6003                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6004                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6005                         }
6006                 }
6007         }
6008         return NDR_ERR_SUCCESS;
6009 }
6010
6011 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameCtr1 *r)
6012 {
6013         uint32_t _ptr_array;
6014         uint32_t cntr_array_1;
6015         TALLOC_CTX *_mem_save_array_0;
6016         TALLOC_CTX *_mem_save_array_1;
6017         if (ndr_flags & NDR_SCALARS) {
6018                 NDR_CHECK(ndr_pull_align(ndr, 5));
6019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6020                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
6021                 if (_ptr_array) {
6022                         NDR_PULL_ALLOC(ndr, r->array);
6023                 } else {
6024                         r->array = NULL;
6025                 }
6026                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6027         }
6028         if (ndr_flags & NDR_BUFFERS) {
6029                 if (r->array) {
6030                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6031                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6032                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
6033                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
6034                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
6035                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6036                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6037                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6038                         }
6039                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6040                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6041                         }
6042                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
6043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
6044                 }
6045                 if (r->array) {
6046                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
6047                 }
6048         }
6049         return NDR_ERR_SUCCESS;
6050 }
6051
6052 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameCtr1 *r)
6053 {
6054         uint32_t cntr_array_1;
6055         ndr_print_struct(ndr, name, "drsuapi_DsNameCtr1");
6056         ndr->depth++;
6057         ndr_print_uint32(ndr, "count", r->count);
6058         ndr_print_ptr(ndr, "array", r->array);
6059         ndr->depth++;
6060         if (r->array) {
6061                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
6062                 ndr->depth++;
6063                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
6064                         char *idx_1=NULL;
6065                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
6066                                 ndr_print_drsuapi_DsNameInfo1(ndr, "array", &r->array[cntr_array_1]);
6067                                 free(idx_1);
6068                         }
6069                 }
6070                 ndr->depth--;
6071         }
6072         ndr->depth--;
6073         ndr->depth--;
6074 }
6075
6076 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameCtr *r)
6077 {
6078         if (ndr_flags & NDR_SCALARS) {
6079                 int level = ndr_push_get_switch_value(ndr, r);
6080                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6081                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6082                 switch (level) {
6083                         case 1: {
6084                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
6085                         break; }
6086
6087                         default:
6088                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6089                 }
6090         }
6091         if (ndr_flags & NDR_BUFFERS) {
6092                 int level = ndr_push_get_switch_value(ndr, r);
6093                 switch (level) {
6094                         case 1:
6095                                 if (r->ctr1) {
6096                                         NDR_CHECK(ndr_push_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6097                                 }
6098                         break;
6099
6100                         default:
6101                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6102                 }
6103         }
6104         return NDR_ERR_SUCCESS;
6105 }
6106
6107 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameCtr *r)
6108 {
6109         int level;
6110         int32_t _level;
6111         TALLOC_CTX *_mem_save_ctr1_0;
6112         level = ndr_pull_get_switch_value(ndr, r);
6113         if (ndr_flags & NDR_SCALARS) {
6114                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6115                 if (_level != level) {
6116                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6117                 }
6118                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6119                 switch (level) {
6120                         case 1: {
6121                                 uint32_t _ptr_ctr1;
6122                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
6123                                 if (_ptr_ctr1) {
6124                                         NDR_PULL_ALLOC(ndr, r->ctr1);
6125                                 } else {
6126                                         r->ctr1 = NULL;
6127                                 }
6128                         break; }
6129
6130                         default:
6131                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6132                 }
6133         }
6134         if (ndr_flags & NDR_BUFFERS) {
6135                 switch (level) {
6136                         case 1:
6137                                 if (r->ctr1) {
6138                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6139                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
6140                                         NDR_CHECK(ndr_pull_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6141                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
6142                                 }
6143                         break;
6144
6145                         default:
6146                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6147                 }
6148         }
6149         return NDR_ERR_SUCCESS;
6150 }
6151
6152 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameCtr *r)
6153 {
6154         int level;
6155         level = ndr_print_get_switch_value(ndr, r);
6156         ndr_print_union(ndr, name, level, "drsuapi_DsNameCtr");
6157         switch (level) {
6158                 case 1:
6159                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
6160                         ndr->depth++;
6161                         if (r->ctr1) {
6162                                 ndr_print_drsuapi_DsNameCtr1(ndr, "ctr1", r->ctr1);
6163                         }
6164                         ndr->depth--;
6165                 break;
6166
6167                 default:
6168                         ndr_print_bad_level(ndr, name, level);
6169         }
6170 }
6171
6172 static enum ndr_err_code ndr_push_drsuapi_DsSpnOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsSpnOperation r)
6173 {
6174         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6175         return NDR_ERR_SUCCESS;
6176 }
6177
6178 static enum ndr_err_code ndr_pull_drsuapi_DsSpnOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsSpnOperation *r)
6179 {
6180         uint32_t v;
6181         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6182         *r = v;
6183         return NDR_ERR_SUCCESS;
6184 }
6185
6186 _PUBLIC_ void ndr_print_drsuapi_DsSpnOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsSpnOperation r)
6187 {
6188         const char *val = NULL;
6189
6190         switch (r) {
6191                 case DRSUAPI_DS_SPN_OPERATION_ADD: val = "DRSUAPI_DS_SPN_OPERATION_ADD"; break;
6192                 case DRSUAPI_DS_SPN_OPERATION_REPLACE: val = "DRSUAPI_DS_SPN_OPERATION_REPLACE"; break;
6193                 case DRSUAPI_DS_SPN_OPERATION_DELETE: val = "DRSUAPI_DS_SPN_OPERATION_DELETE"; break;
6194         }
6195         ndr_print_enum(ndr, name, "ENUM", val, r);
6196 }
6197
6198 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6199 {
6200         uint32_t cntr_spn_names_1;
6201         if (ndr_flags & NDR_SCALARS) {
6202                 NDR_CHECK(ndr_push_align(ndr, 5));
6203                 NDR_CHECK(ndr_push_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, r->operation));
6204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
6205                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
6206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6207                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
6208                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6209         }
6210         if (ndr_flags & NDR_BUFFERS) {
6211                 if (r->object_dn) {
6212                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6213                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6214                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6215                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6216                 }
6217                 if (r->spn_names) {
6218                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6219                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6220                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6221                         }
6222                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6223                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6224                         }
6225                 }
6226         }
6227         return NDR_ERR_SUCCESS;
6228 }
6229
6230 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnRequest1 *r)
6231 {
6232         uint32_t _ptr_object_dn;
6233         TALLOC_CTX *_mem_save_object_dn_0;
6234         uint32_t _ptr_spn_names;
6235         uint32_t cntr_spn_names_1;
6236         TALLOC_CTX *_mem_save_spn_names_0;
6237         TALLOC_CTX *_mem_save_spn_names_1;
6238         if (ndr_flags & NDR_SCALARS) {
6239                 NDR_CHECK(ndr_pull_align(ndr, 5));
6240                 NDR_CHECK(ndr_pull_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, &r->operation));
6241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
6242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
6243                 if (_ptr_object_dn) {
6244                         NDR_PULL_ALLOC(ndr, r->object_dn);
6245                 } else {
6246                         r->object_dn = NULL;
6247                 }
6248                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6249                 if (r->count > 10000) {
6250                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6251                 }
6252                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_spn_names));
6253                 if (_ptr_spn_names) {
6254                         NDR_PULL_ALLOC(ndr, r->spn_names);
6255                 } else {
6256                         r->spn_names = NULL;
6257                 }
6258                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6259         }
6260         if (ndr_flags & NDR_BUFFERS) {
6261                 if (r->object_dn) {
6262                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6263                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
6264                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
6265                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
6266                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
6267                                 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));
6268                         }
6269                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
6270                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
6271                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
6272                 }
6273                 if (r->spn_names) {
6274                         _mem_save_spn_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6275                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6276                         NDR_CHECK(ndr_pull_array_size(ndr, &r->spn_names));
6277                         NDR_PULL_ALLOC_N(ndr, r->spn_names, ndr_get_array_size(ndr, &r->spn_names));
6278                         _mem_save_spn_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
6279                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6280                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6281                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6282                         }
6283                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6284                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6285                         }
6286                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_1, 0);
6287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_0, 0);
6288                 }
6289                 if (r->spn_names) {
6290                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->spn_names, r->count));
6291                 }
6292         }
6293         return NDR_ERR_SUCCESS;
6294 }
6295
6296 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6297 {
6298         uint32_t cntr_spn_names_1;
6299         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnRequest1");
6300         ndr->depth++;
6301         ndr_print_drsuapi_DsSpnOperation(ndr, "operation", r->operation);
6302         ndr_print_uint32(ndr, "unknown1", r->unknown1);
6303         ndr_print_ptr(ndr, "object_dn", r->object_dn);
6304         ndr->depth++;
6305         if (r->object_dn) {
6306                 ndr_print_string(ndr, "object_dn", r->object_dn);
6307         }
6308         ndr->depth--;
6309         ndr_print_uint32(ndr, "count", r->count);
6310         ndr_print_ptr(ndr, "spn_names", r->spn_names);
6311         ndr->depth++;
6312         if (r->spn_names) {
6313                 ndr->print(ndr, "%s: ARRAY(%d)", "spn_names", (int)r->count);
6314                 ndr->depth++;
6315                 for (cntr_spn_names_1=0;cntr_spn_names_1<r->count;cntr_spn_names_1++) {
6316                         char *idx_1=NULL;
6317                         if (asprintf(&idx_1, "[%d]", cntr_spn_names_1) != -1) {
6318                                 ndr_print_drsuapi_DsNameString(ndr, "spn_names", &r->spn_names[cntr_spn_names_1]);
6319                                 free(idx_1);
6320                         }
6321                 }
6322                 ndr->depth--;
6323         }
6324         ndr->depth--;
6325         ndr->depth--;
6326 }
6327
6328 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnRequest *r)
6329 {
6330         if (ndr_flags & NDR_SCALARS) {
6331                 int level = ndr_push_get_switch_value(ndr, r);
6332                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6333                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6334                 switch (level) {
6335                         case 1: {
6336                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6337                         break; }
6338
6339                         default:
6340                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6341                 }
6342         }
6343         if (ndr_flags & NDR_BUFFERS) {
6344                 int level = ndr_push_get_switch_value(ndr, r);
6345                 switch (level) {
6346                         case 1:
6347                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6348                         break;
6349
6350                         default:
6351                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6352                 }
6353         }
6354         return NDR_ERR_SUCCESS;
6355 }
6356
6357 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnRequest *r)
6358 {
6359         int level;
6360         int32_t _level;
6361         level = ndr_pull_get_switch_value(ndr, r);
6362         if (ndr_flags & NDR_SCALARS) {
6363                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6364                 if (_level != level) {
6365                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6366                 }
6367                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6368                 switch (level) {
6369                         case 1: {
6370                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6371                         break; }
6372
6373                         default:
6374                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6375                 }
6376         }
6377         if (ndr_flags & NDR_BUFFERS) {
6378                 switch (level) {
6379                         case 1:
6380                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6381                         break;
6382
6383                         default:
6384                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6385                 }
6386         }
6387         return NDR_ERR_SUCCESS;
6388 }
6389
6390 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnRequest *r)
6391 {
6392         int level;
6393         level = ndr_print_get_switch_value(ndr, r);
6394         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnRequest");
6395         switch (level) {
6396                 case 1:
6397                         ndr_print_drsuapi_DsWriteAccountSpnRequest1(ndr, "req1", &r->req1);
6398                 break;
6399
6400                 default:
6401                         ndr_print_bad_level(ndr, name, level);
6402         }
6403 }
6404
6405 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6406 {
6407         if (ndr_flags & NDR_SCALARS) {
6408                 NDR_CHECK(ndr_push_align(ndr, 4));
6409                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
6410                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6411         }
6412         if (ndr_flags & NDR_BUFFERS) {
6413         }
6414         return NDR_ERR_SUCCESS;
6415 }
6416
6417 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnResult1 *r)
6418 {
6419         if (ndr_flags & NDR_SCALARS) {
6420                 NDR_CHECK(ndr_pull_align(ndr, 4));
6421                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
6422                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6423         }
6424         if (ndr_flags & NDR_BUFFERS) {
6425         }
6426         return NDR_ERR_SUCCESS;
6427 }
6428
6429 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6430 {
6431         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnResult1");
6432         ndr->depth++;
6433         ndr_print_WERROR(ndr, "status", r->status);
6434         ndr->depth--;
6435 }
6436
6437 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnResult *r)
6438 {
6439         if (ndr_flags & NDR_SCALARS) {
6440                 int level = ndr_push_get_switch_value(ndr, r);
6441                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6442                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6443                 switch (level) {
6444                         case 1: {
6445                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6446                         break; }
6447
6448                         default:
6449                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6450                 }
6451         }
6452         if (ndr_flags & NDR_BUFFERS) {
6453                 int level = ndr_push_get_switch_value(ndr, r);
6454                 switch (level) {
6455                         case 1:
6456                         break;
6457
6458                         default:
6459                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6460                 }
6461         }
6462         return NDR_ERR_SUCCESS;
6463 }
6464
6465 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnResult *r)
6466 {
6467         int level;
6468         int32_t _level;
6469         level = ndr_pull_get_switch_value(ndr, r);
6470         if (ndr_flags & NDR_SCALARS) {
6471                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6472                 if (_level != level) {
6473                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6474                 }
6475                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6476                 switch (level) {
6477                         case 1: {
6478                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6479                         break; }
6480
6481                         default:
6482                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6483                 }
6484         }
6485         if (ndr_flags & NDR_BUFFERS) {
6486                 switch (level) {
6487                         case 1:
6488                         break;
6489
6490                         default:
6491                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6492                 }
6493         }
6494         return NDR_ERR_SUCCESS;
6495 }
6496
6497 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnResult *r)
6498 {
6499         int level;
6500         level = ndr_print_get_switch_value(ndr, r);
6501         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnResult");
6502         switch (level) {
6503                 case 1:
6504                         ndr_print_drsuapi_DsWriteAccountSpnResult1(ndr, "res1", &r->res1);
6505                 break;
6506
6507                 default:
6508                         ndr_print_bad_level(ndr, name, level);
6509         }
6510 }
6511
6512 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6513 {
6514         if (ndr_flags & NDR_SCALARS) {
6515                 NDR_CHECK(ndr_push_align(ndr, 5));
6516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6517                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
6518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->commit));
6519                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6520         }
6521         if (ndr_flags & NDR_BUFFERS) {
6522                 if (r->server_dn) {
6523                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6524                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6525                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6526                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6527                 }
6528                 if (r->domain_dn) {
6529                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6530                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6531                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6532                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_dn, ndr_charset_length(r->domain_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6533                 }
6534         }
6535         return NDR_ERR_SUCCESS;
6536 }
6537
6538 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerRequest1 *r)
6539 {
6540         uint32_t _ptr_server_dn;
6541         TALLOC_CTX *_mem_save_server_dn_0;
6542         uint32_t _ptr_domain_dn;
6543         TALLOC_CTX *_mem_save_domain_dn_0;
6544         if (ndr_flags & NDR_SCALARS) {
6545                 NDR_CHECK(ndr_pull_align(ndr, 5));
6546                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6547                 if (_ptr_server_dn) {
6548                         NDR_PULL_ALLOC(ndr, r->server_dn);
6549                 } else {
6550                         r->server_dn = NULL;
6551                 }
6552                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_dn));
6553                 if (_ptr_domain_dn) {
6554                         NDR_PULL_ALLOC(ndr, r->domain_dn);
6555                 } else {
6556                         r->domain_dn = NULL;
6557                 }
6558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->commit));
6559                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6560         }
6561         if (ndr_flags & NDR_BUFFERS) {
6562                 if (r->server_dn) {
6563                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6564                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6565                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6566                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6567                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6568                                 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));
6569                         }
6570                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6571                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6572                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6573                 }
6574                 if (r->domain_dn) {
6575                         _mem_save_domain_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6576                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_dn, 0);
6577                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_dn));
6578                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_dn));
6579                         if (ndr_get_array_length(ndr, &r->domain_dn) > ndr_get_array_size(ndr, &r->domain_dn)) {
6580                                 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));
6581                         }
6582                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t)));
6583                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t), CH_UTF16));
6584                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_dn_0, 0);
6585                 }
6586         }
6587         return NDR_ERR_SUCCESS;
6588 }
6589
6590 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6591 {
6592         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerRequest1");
6593         ndr->depth++;
6594         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6595         ndr->depth++;
6596         if (r->server_dn) {
6597                 ndr_print_string(ndr, "server_dn", r->server_dn);
6598         }
6599         ndr->depth--;
6600         ndr_print_ptr(ndr, "domain_dn", r->domain_dn);
6601         ndr->depth++;
6602         if (r->domain_dn) {
6603                 ndr_print_string(ndr, "domain_dn", r->domain_dn);
6604         }
6605         ndr->depth--;
6606         ndr_print_uint32(ndr, "commit", r->commit);
6607         ndr->depth--;
6608 }
6609
6610 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerRequest *r)
6611 {
6612         if (ndr_flags & NDR_SCALARS) {
6613                 int level = ndr_push_get_switch_value(ndr, r);
6614                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6615                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6616                 switch (level) {
6617                         case 1: {
6618                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6619                         break; }
6620
6621                         default:
6622                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6623                 }
6624         }
6625         if (ndr_flags & NDR_BUFFERS) {
6626                 int level = ndr_push_get_switch_value(ndr, r);
6627                 switch (level) {
6628                         case 1:
6629                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6630                         break;
6631
6632                         default:
6633                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6634                 }
6635         }
6636         return NDR_ERR_SUCCESS;
6637 }
6638
6639 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerRequest *r)
6640 {
6641         int level;
6642         int32_t _level;
6643         level = ndr_pull_get_switch_value(ndr, r);
6644         if (ndr_flags & NDR_SCALARS) {
6645                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6646                 if (_level != level) {
6647                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6648                 }
6649                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6650                 switch (level) {
6651                         case 1: {
6652                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6653                         break; }
6654
6655                         default:
6656                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6657                 }
6658         }
6659         if (ndr_flags & NDR_BUFFERS) {
6660                 switch (level) {
6661                         case 1:
6662                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6663                         break;
6664
6665                         default:
6666                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6667                 }
6668         }
6669         return NDR_ERR_SUCCESS;
6670 }
6671
6672 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerRequest *r)
6673 {
6674         int level;
6675         level = ndr_print_get_switch_value(ndr, r);
6676         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerRequest");
6677         switch (level) {
6678                 case 1:
6679                         ndr_print_drsuapi_DsRemoveDSServerRequest1(ndr, "req1", &r->req1);
6680                 break;
6681
6682                 default:
6683                         ndr_print_bad_level(ndr, name, level);
6684         }
6685 }
6686
6687 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerResult1 *r)
6688 {
6689         if (ndr_flags & NDR_SCALARS) {
6690                 NDR_CHECK(ndr_push_align(ndr, 4));
6691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->last_dc_in_domain));
6692                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6693         }
6694         if (ndr_flags & NDR_BUFFERS) {
6695         }
6696         return NDR_ERR_SUCCESS;
6697 }
6698
6699 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerResult1 *r)
6700 {
6701         if (ndr_flags & NDR_SCALARS) {
6702                 NDR_CHECK(ndr_pull_align(ndr, 4));
6703                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->last_dc_in_domain));
6704                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6705         }
6706         if (ndr_flags & NDR_BUFFERS) {
6707         }
6708         return NDR_ERR_SUCCESS;
6709 }
6710
6711 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerResult1 *r)
6712 {
6713         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerResult1");
6714         ndr->depth++;
6715         ndr_print_uint32(ndr, "last_dc_in_domain", r->last_dc_in_domain);
6716         ndr->depth--;
6717 }
6718
6719 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerResult *r)
6720 {
6721         if (ndr_flags & NDR_SCALARS) {
6722                 int level = ndr_push_get_switch_value(ndr, r);
6723                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6724                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6725                 switch (level) {
6726                         case 1: {
6727                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6728                         break; }
6729
6730                         default:
6731                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6732                 }
6733         }
6734         if (ndr_flags & NDR_BUFFERS) {
6735                 int level = ndr_push_get_switch_value(ndr, r);
6736                 switch (level) {
6737                         case 1:
6738                         break;
6739
6740                         default:
6741                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6742                 }
6743         }
6744         return NDR_ERR_SUCCESS;
6745 }
6746
6747 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerResult *r)
6748 {
6749         int level;
6750         int32_t _level;
6751         level = ndr_pull_get_switch_value(ndr, r);
6752         if (ndr_flags & NDR_SCALARS) {
6753                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6754                 if (_level != level) {
6755                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6756                 }
6757                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6758                 switch (level) {
6759                         case 1: {
6760                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6761                         break; }
6762
6763                         default:
6764                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6765                 }
6766         }
6767         if (ndr_flags & NDR_BUFFERS) {
6768                 switch (level) {
6769                         case 1:
6770                         break;
6771
6772                         default:
6773                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6774                 }
6775         }
6776         return NDR_ERR_SUCCESS;
6777 }
6778
6779 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerResult *r)
6780 {
6781         int level;
6782         level = ndr_print_get_switch_value(ndr, r);
6783         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerResult");
6784         switch (level) {
6785                 case 1:
6786                         ndr_print_drsuapi_DsRemoveDSServerResult1(ndr, "res1", &r->res1);
6787                 break;
6788
6789                 default:
6790                         ndr_print_bad_level(ndr, name, level);
6791         }
6792 }
6793
6794 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoRequest1 *r)
6795 {
6796         if (ndr_flags & NDR_SCALARS) {
6797                 NDR_CHECK(ndr_push_align(ndr, 5));
6798                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
6799                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
6800                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6801         }
6802         if (ndr_flags & NDR_BUFFERS) {
6803                 if (r->domain_name) {
6804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6805                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6806                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6807                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6808                 }
6809         }
6810         return NDR_ERR_SUCCESS;
6811 }
6812
6813 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoRequest1 *r)
6814 {
6815         uint32_t _ptr_domain_name;
6816         TALLOC_CTX *_mem_save_domain_name_0;
6817         if (ndr_flags & NDR_SCALARS) {
6818                 NDR_CHECK(ndr_pull_align(ndr, 5));
6819                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
6820                 if (_ptr_domain_name) {
6821                         NDR_PULL_ALLOC(ndr, r->domain_name);
6822                 } else {
6823                         r->domain_name = NULL;
6824                 }
6825                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
6826                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6827         }
6828         if (ndr_flags & NDR_BUFFERS) {
6829                 if (r->domain_name) {
6830                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6831                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
6832                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
6833                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
6834                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
6835                                 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));
6836                         }
6837                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
6838                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
6839                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
6840                 }
6841         }
6842         return NDR_ERR_SUCCESS;
6843 }
6844
6845 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoRequest1 *r)
6846 {
6847         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoRequest1");
6848         ndr->depth++;
6849         ndr_print_ptr(ndr, "domain_name", r->domain_name);
6850         ndr->depth++;
6851         if (r->domain_name) {
6852                 ndr_print_string(ndr, "domain_name", r->domain_name);
6853         }
6854         ndr->depth--;
6855         ndr_print_int32(ndr, "level", r->level);
6856         ndr->depth--;
6857 }
6858
6859 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoRequest *r)
6860 {
6861         if (ndr_flags & NDR_SCALARS) {
6862                 int level = ndr_push_get_switch_value(ndr, r);
6863                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6864                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6865                 switch (level) {
6866                         case 1: {
6867                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6868                         break; }
6869
6870                         default:
6871                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6872                 }
6873         }
6874         if (ndr_flags & NDR_BUFFERS) {
6875                 int level = ndr_push_get_switch_value(ndr, r);
6876                 switch (level) {
6877                         case 1:
6878                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6879                         break;
6880
6881                         default:
6882                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6883                 }
6884         }
6885         return NDR_ERR_SUCCESS;
6886 }
6887
6888 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoRequest *r)
6889 {
6890         int level;
6891         int32_t _level;
6892         level = ndr_pull_get_switch_value(ndr, r);
6893         if (ndr_flags & NDR_SCALARS) {
6894                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6895                 if (_level != level) {
6896                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6897                 }
6898                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6899                 switch (level) {
6900                         case 1: {
6901                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6902                         break; }
6903
6904                         default:
6905                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6906                 }
6907         }
6908         if (ndr_flags & NDR_BUFFERS) {
6909                 switch (level) {
6910                         case 1:
6911                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6912                         break;
6913
6914                         default:
6915                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6916                 }
6917         }
6918         return NDR_ERR_SUCCESS;
6919 }
6920
6921 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoRequest *r)
6922 {
6923         int level;
6924         level = ndr_print_get_switch_value(ndr, r);
6925         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoRequest");
6926         switch (level) {
6927                 case 1:
6928                         ndr_print_drsuapi_DsGetDCInfoRequest1(ndr, "req1", &r->req1);
6929                 break;
6930
6931                 default:
6932                         ndr_print_bad_level(ndr, name, level);
6933         }
6934 }
6935
6936 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo1 *r)
6937 {
6938         if (ndr_flags & NDR_SCALARS) {
6939                 NDR_CHECK(ndr_push_align(ndr, 5));
6940                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6942                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6944                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6947                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6948         }
6949         if (ndr_flags & NDR_BUFFERS) {
6950                 if (r->netbios_name) {
6951                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6952                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6953                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6954                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6955                 }
6956                 if (r->dns_name) {
6957                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6958                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6959                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6960                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6961                 }
6962                 if (r->site_name) {
6963                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6964                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6965                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6966                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6967                 }
6968                 if (r->computer_dn) {
6969                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6970                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6971                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6972                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6973                 }
6974                 if (r->server_dn) {
6975                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6976                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6977                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6978                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6979                 }
6980         }
6981         return NDR_ERR_SUCCESS;
6982 }
6983
6984 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo1 *r)
6985 {
6986         uint32_t _ptr_netbios_name;
6987         TALLOC_CTX *_mem_save_netbios_name_0;
6988         uint32_t _ptr_dns_name;
6989         TALLOC_CTX *_mem_save_dns_name_0;
6990         uint32_t _ptr_site_name;
6991         TALLOC_CTX *_mem_save_site_name_0;
6992         uint32_t _ptr_computer_dn;
6993         TALLOC_CTX *_mem_save_computer_dn_0;
6994         uint32_t _ptr_server_dn;
6995         TALLOC_CTX *_mem_save_server_dn_0;
6996         if (ndr_flags & NDR_SCALARS) {
6997                 NDR_CHECK(ndr_pull_align(ndr, 5));
6998                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
6999                 if (_ptr_netbios_name) {
7000                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7001                 } else {
7002                         r->netbios_name = NULL;
7003                 }
7004                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7005                 if (_ptr_dns_name) {
7006                         NDR_PULL_ALLOC(ndr, r->dns_name);
7007                 } else {
7008                         r->dns_name = NULL;
7009                 }
7010                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7011                 if (_ptr_site_name) {
7012                         NDR_PULL_ALLOC(ndr, r->site_name);
7013                 } else {
7014                         r->site_name = NULL;
7015                 }
7016                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7017                 if (_ptr_computer_dn) {
7018                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7019                 } else {
7020                         r->computer_dn = NULL;
7021                 }
7022                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7023                 if (_ptr_server_dn) {
7024                         NDR_PULL_ALLOC(ndr, r->server_dn);
7025                 } else {
7026                         r->server_dn = NULL;
7027                 }
7028                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7030                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7031         }
7032         if (ndr_flags & NDR_BUFFERS) {
7033                 if (r->netbios_name) {
7034                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7035                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7036                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7037                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7038                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
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->netbios_name), ndr_get_array_length(ndr, &r->netbios_name));
7040                         }
7041                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7042                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7044                 }
7045                 if (r->dns_name) {
7046                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7047                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7048                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7049                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7050                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7051                                 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));
7052                         }
7053                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7054                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7056                 }
7057                 if (r->site_name) {
7058                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7059                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7060                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7061                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7062                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7063                                 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));
7064                         }
7065                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7066                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7068                 }
7069                 if (r->computer_dn) {
7070                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7071                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7072                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7073                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7074                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7075                                 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));
7076                         }
7077                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7078                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7080                 }
7081                 if (r->server_dn) {
7082                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7083                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7084                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7085                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7086                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7087                                 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));
7088                         }
7089                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7090                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7091                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7092                 }
7093         }
7094         return NDR_ERR_SUCCESS;
7095 }
7096
7097 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo1 *r)
7098 {
7099         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo1");
7100         ndr->depth++;
7101         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7102         ndr->depth++;
7103         if (r->netbios_name) {
7104                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7105         }
7106         ndr->depth--;
7107         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7108         ndr->depth++;
7109         if (r->dns_name) {
7110                 ndr_print_string(ndr, "dns_name", r->dns_name);
7111         }
7112         ndr->depth--;
7113         ndr_print_ptr(ndr, "site_name", r->site_name);
7114         ndr->depth++;
7115         if (r->site_name) {
7116                 ndr_print_string(ndr, "site_name", r->site_name);
7117         }
7118         ndr->depth--;
7119         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7120         ndr->depth++;
7121         if (r->computer_dn) {
7122                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7123         }
7124         ndr->depth--;
7125         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7126         ndr->depth++;
7127         if (r->server_dn) {
7128                 ndr_print_string(ndr, "server_dn", r->server_dn);
7129         }
7130         ndr->depth--;
7131         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7132         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7133         ndr->depth--;
7134 }
7135
7136 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr1 *r)
7137 {
7138         uint32_t cntr_array_1;
7139         if (ndr_flags & NDR_SCALARS) {
7140                 NDR_CHECK(ndr_push_align(ndr, 5));
7141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7142                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7143                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7144         }
7145         if (ndr_flags & NDR_BUFFERS) {
7146                 if (r->array) {
7147                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7148                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7149                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7150                         }
7151                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7152                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7153                         }
7154                 }
7155         }
7156         return NDR_ERR_SUCCESS;
7157 }
7158
7159 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr1 *r)
7160 {
7161         uint32_t _ptr_array;
7162         uint32_t cntr_array_1;
7163         TALLOC_CTX *_mem_save_array_0;
7164         TALLOC_CTX *_mem_save_array_1;
7165         if (ndr_flags & NDR_SCALARS) {
7166                 NDR_CHECK(ndr_pull_align(ndr, 5));
7167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7168                 if (r->count > 10000) {
7169                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7170                 }
7171                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7172                 if (_ptr_array) {
7173                         NDR_PULL_ALLOC(ndr, r->array);
7174                 } else {
7175                         r->array = NULL;
7176                 }
7177                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7178         }
7179         if (ndr_flags & NDR_BUFFERS) {
7180                 if (r->array) {
7181                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7182                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7183                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7184                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7185                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7186                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7187                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7188                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7189                         }
7190                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7191                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7192                         }
7193                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7195                 }
7196                 if (r->array) {
7197                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7198                 }
7199         }
7200         return NDR_ERR_SUCCESS;
7201 }
7202
7203 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr1 *r)
7204 {
7205         uint32_t cntr_array_1;
7206         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr1");
7207         ndr->depth++;
7208         ndr_print_uint32(ndr, "count", r->count);
7209         ndr_print_ptr(ndr, "array", r->array);
7210         ndr->depth++;
7211         if (r->array) {
7212                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7213                 ndr->depth++;
7214                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7215                         char *idx_1=NULL;
7216                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7217                                 ndr_print_drsuapi_DsGetDCInfo1(ndr, "array", &r->array[cntr_array_1]);
7218                                 free(idx_1);
7219                         }
7220                 }
7221                 ndr->depth--;
7222         }
7223         ndr->depth--;
7224         ndr->depth--;
7225 }
7226
7227 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo2 *r)
7228 {
7229         if (ndr_flags & NDR_SCALARS) {
7230                 NDR_CHECK(ndr_push_align(ndr, 5));
7231                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7232                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7233                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7234                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7235                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7236                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7237                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7240                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7241                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7242                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7243                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7244                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7245                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7246         }
7247         if (ndr_flags & NDR_BUFFERS) {
7248                 if (r->netbios_name) {
7249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7250                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7251                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7252                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7253                 }
7254                 if (r->dns_name) {
7255                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7256                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7257                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7258                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7259                 }
7260                 if (r->site_name) {
7261                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7262                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7263                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7264                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7265                 }
7266                 if (r->site_dn) {
7267                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7268                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7269                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7270                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7271                 }
7272                 if (r->computer_dn) {
7273                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7274                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7275                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7276                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7277                 }
7278                 if (r->server_dn) {
7279                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7280                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7281                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7282                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7283                 }
7284                 if (r->ntds_dn) {
7285                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7286                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7287                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7288                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7289                 }
7290         }
7291         return NDR_ERR_SUCCESS;
7292 }
7293
7294 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo2 *r)
7295 {
7296         uint32_t _ptr_netbios_name;
7297         TALLOC_CTX *_mem_save_netbios_name_0;
7298         uint32_t _ptr_dns_name;
7299         TALLOC_CTX *_mem_save_dns_name_0;
7300         uint32_t _ptr_site_name;
7301         TALLOC_CTX *_mem_save_site_name_0;
7302         uint32_t _ptr_site_dn;
7303         TALLOC_CTX *_mem_save_site_dn_0;
7304         uint32_t _ptr_computer_dn;
7305         TALLOC_CTX *_mem_save_computer_dn_0;
7306         uint32_t _ptr_server_dn;
7307         TALLOC_CTX *_mem_save_server_dn_0;
7308         uint32_t _ptr_ntds_dn;
7309         TALLOC_CTX *_mem_save_ntds_dn_0;
7310         if (ndr_flags & NDR_SCALARS) {
7311                 NDR_CHECK(ndr_pull_align(ndr, 5));
7312                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7313                 if (_ptr_netbios_name) {
7314                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7315                 } else {
7316                         r->netbios_name = NULL;
7317                 }
7318                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7319                 if (_ptr_dns_name) {
7320                         NDR_PULL_ALLOC(ndr, r->dns_name);
7321                 } else {
7322                         r->dns_name = NULL;
7323                 }
7324                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7325                 if (_ptr_site_name) {
7326                         NDR_PULL_ALLOC(ndr, r->site_name);
7327                 } else {
7328                         r->site_name = NULL;
7329                 }
7330                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7331                 if (_ptr_site_dn) {
7332                         NDR_PULL_ALLOC(ndr, r->site_dn);
7333                 } else {
7334                         r->site_dn = NULL;
7335                 }
7336                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7337                 if (_ptr_computer_dn) {
7338                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7339                 } else {
7340                         r->computer_dn = NULL;
7341                 }
7342                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7343                 if (_ptr_server_dn) {
7344                         NDR_PULL_ALLOC(ndr, r->server_dn);
7345                 } else {
7346                         r->server_dn = NULL;
7347                 }
7348                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7349                 if (_ptr_ntds_dn) {
7350                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7351                 } else {
7352                         r->ntds_dn = NULL;
7353                 }
7354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7357                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7358                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7359                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7360                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7361                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7362         }
7363         if (ndr_flags & NDR_BUFFERS) {
7364                 if (r->netbios_name) {
7365                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7366                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7367                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7368                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7369                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
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->netbios_name), ndr_get_array_length(ndr, &r->netbios_name));
7371                         }
7372                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7373                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7374                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7375                 }
7376                 if (r->dns_name) {
7377                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7378                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7379                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7380                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7381                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
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->dns_name), ndr_get_array_length(ndr, &r->dns_name));
7383                         }
7384                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7385                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7386                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7387                 }
7388                 if (r->site_name) {
7389                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7390                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7391                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7392                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7393                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
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->site_name), ndr_get_array_length(ndr, &r->site_name));
7395                         }
7396                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7397                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7398                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7399                 }
7400                 if (r->site_dn) {
7401                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7402                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7403                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7404                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7405                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7406                                 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));
7407                         }
7408                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7409                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7410                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7411                 }
7412                 if (r->computer_dn) {
7413                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7414                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7415                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7416                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7417                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7418                                 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));
7419                         }
7420                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7421                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7422                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7423                 }
7424                 if (r->server_dn) {
7425                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7426                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7427                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7428                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7429                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7430                                 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));
7431                         }
7432                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7433                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7434                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7435                 }
7436                 if (r->ntds_dn) {
7437                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7438                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7439                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7440                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7441                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7442                                 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));
7443                         }
7444                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7445                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7446                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7447                 }
7448         }
7449         return NDR_ERR_SUCCESS;
7450 }
7451
7452 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo2 *r)
7453 {
7454         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo2");
7455         ndr->depth++;
7456         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7457         ndr->depth++;
7458         if (r->netbios_name) {
7459                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7460         }
7461         ndr->depth--;
7462         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7463         ndr->depth++;
7464         if (r->dns_name) {
7465                 ndr_print_string(ndr, "dns_name", r->dns_name);
7466         }
7467         ndr->depth--;
7468         ndr_print_ptr(ndr, "site_name", r->site_name);
7469         ndr->depth++;
7470         if (r->site_name) {
7471                 ndr_print_string(ndr, "site_name", r->site_name);
7472         }
7473         ndr->depth--;
7474         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7475         ndr->depth++;
7476         if (r->site_dn) {
7477                 ndr_print_string(ndr, "site_dn", r->site_dn);
7478         }
7479         ndr->depth--;
7480         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7481         ndr->depth++;
7482         if (r->computer_dn) {
7483                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7484         }
7485         ndr->depth--;
7486         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7487         ndr->depth++;
7488         if (r->server_dn) {
7489                 ndr_print_string(ndr, "server_dn", r->server_dn);
7490         }
7491         ndr->depth--;
7492         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7493         ndr->depth++;
7494         if (r->ntds_dn) {
7495                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7496         }
7497         ndr->depth--;
7498         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7499         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7500         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7501         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7502         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7503         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7504         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7505         ndr->depth--;
7506 }
7507
7508 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr2 *r)
7509 {
7510         uint32_t cntr_array_1;
7511         if (ndr_flags & NDR_SCALARS) {
7512                 NDR_CHECK(ndr_push_align(ndr, 5));
7513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7514                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7515                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7516         }
7517         if (ndr_flags & NDR_BUFFERS) {
7518                 if (r->array) {
7519                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7520                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7521                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7522                         }
7523                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7524                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7525                         }
7526                 }
7527         }
7528         return NDR_ERR_SUCCESS;
7529 }
7530
7531 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr2 *r)
7532 {
7533         uint32_t _ptr_array;
7534         uint32_t cntr_array_1;
7535         TALLOC_CTX *_mem_save_array_0;
7536         TALLOC_CTX *_mem_save_array_1;
7537         if (ndr_flags & NDR_SCALARS) {
7538                 NDR_CHECK(ndr_pull_align(ndr, 5));
7539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7540                 if (r->count > 10000) {
7541                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7542                 }
7543                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7544                 if (_ptr_array) {
7545                         NDR_PULL_ALLOC(ndr, r->array);
7546                 } else {
7547                         r->array = NULL;
7548                 }
7549                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7550         }
7551         if (ndr_flags & NDR_BUFFERS) {
7552                 if (r->array) {
7553                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7554                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7555                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7556                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7557                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7558                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7559                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7560                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7561                         }
7562                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7563                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7564                         }
7565                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7566                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7567                 }
7568                 if (r->array) {
7569                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7570                 }
7571         }
7572         return NDR_ERR_SUCCESS;
7573 }
7574
7575 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr2 *r)
7576 {
7577         uint32_t cntr_array_1;
7578         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr2");
7579         ndr->depth++;
7580         ndr_print_uint32(ndr, "count", r->count);
7581         ndr_print_ptr(ndr, "array", r->array);
7582         ndr->depth++;
7583         if (r->array) {
7584                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7585                 ndr->depth++;
7586                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7587                         char *idx_1=NULL;
7588                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7589                                 ndr_print_drsuapi_DsGetDCInfo2(ndr, "array", &r->array[cntr_array_1]);
7590                                 free(idx_1);
7591                         }
7592                 }
7593                 ndr->depth--;
7594         }
7595         ndr->depth--;
7596         ndr->depth--;
7597 }
7598
7599 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo3 *r)
7600 {
7601         if (ndr_flags & NDR_SCALARS) {
7602                 NDR_CHECK(ndr_push_align(ndr, 5));
7603                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7605                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7608                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7609                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7611                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7613                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_rodc));
7614                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7615                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7616                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7617                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7618                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7619         }
7620         if (ndr_flags & NDR_BUFFERS) {
7621                 if (r->netbios_name) {
7622                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7623                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7624                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7625                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7626                 }
7627                 if (r->dns_name) {
7628                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7629                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7630                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7631                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7632                 }
7633                 if (r->site_name) {
7634                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7635                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7636                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7637                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7638                 }
7639                 if (r->site_dn) {
7640                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7641                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7642                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7643                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7644                 }
7645                 if (r->computer_dn) {
7646                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7647                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7648                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7649                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7650                 }
7651                 if (r->server_dn) {
7652                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7653                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7655                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7656                 }
7657                 if (r->ntds_dn) {
7658                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7659                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7660                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7661                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7662                 }
7663         }
7664         return NDR_ERR_SUCCESS;
7665 }
7666
7667 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo3 *r)
7668 {
7669         uint32_t _ptr_netbios_name;
7670         TALLOC_CTX *_mem_save_netbios_name_0;
7671         uint32_t _ptr_dns_name;
7672         TALLOC_CTX *_mem_save_dns_name_0;
7673         uint32_t _ptr_site_name;
7674         TALLOC_CTX *_mem_save_site_name_0;
7675         uint32_t _ptr_site_dn;
7676         TALLOC_CTX *_mem_save_site_dn_0;
7677         uint32_t _ptr_computer_dn;
7678         TALLOC_CTX *_mem_save_computer_dn_0;
7679         uint32_t _ptr_server_dn;
7680         TALLOC_CTX *_mem_save_server_dn_0;
7681         uint32_t _ptr_ntds_dn;
7682         TALLOC_CTX *_mem_save_ntds_dn_0;
7683         if (ndr_flags & NDR_SCALARS) {
7684                 NDR_CHECK(ndr_pull_align(ndr, 5));
7685                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7686                 if (_ptr_netbios_name) {
7687                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7688                 } else {
7689                         r->netbios_name = NULL;
7690                 }
7691                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7692                 if (_ptr_dns_name) {
7693                         NDR_PULL_ALLOC(ndr, r->dns_name);
7694                 } else {
7695                         r->dns_name = NULL;
7696                 }
7697                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7698                 if (_ptr_site_name) {
7699                         NDR_PULL_ALLOC(ndr, r->site_name);
7700                 } else {
7701                         r->site_name = NULL;
7702                 }
7703                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7704                 if (_ptr_site_dn) {
7705                         NDR_PULL_ALLOC(ndr, r->site_dn);
7706                 } else {
7707                         r->site_dn = NULL;
7708                 }
7709                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7710                 if (_ptr_computer_dn) {
7711                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7712                 } else {
7713                         r->computer_dn = NULL;
7714                 }
7715                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7716                 if (_ptr_server_dn) {
7717                         NDR_PULL_ALLOC(ndr, r->server_dn);
7718                 } else {
7719                         r->server_dn = NULL;
7720                 }
7721                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7722                 if (_ptr_ntds_dn) {
7723                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7724                 } else {
7725                         r->ntds_dn = NULL;
7726                 }
7727                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7728                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7729                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_rodc));
7731                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7732                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7733                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7734                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7735                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7736         }
7737         if (ndr_flags & NDR_BUFFERS) {
7738                 if (r->netbios_name) {
7739                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7740                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7741                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7742                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7743                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
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->netbios_name), ndr_get_array_length(ndr, &r->netbios_name));
7745                         }
7746                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7747                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7749                 }
7750                 if (r->dns_name) {
7751                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7752                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7753                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7754                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7755                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
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->dns_name), ndr_get_array_length(ndr, &r->dns_name));
7757                         }
7758                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7759                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7761                 }
7762                 if (r->site_name) {
7763                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7764                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7765                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7766                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7767                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
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->site_name), ndr_get_array_length(ndr, &r->site_name));
7769                         }
7770                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7771                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7772                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7773                 }
7774                 if (r->site_dn) {
7775                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7776                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7777                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7778                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7779                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7780                                 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));
7781                         }
7782                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7783                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7784                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7785                 }
7786                 if (r->computer_dn) {
7787                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7788                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7789                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7790                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7791                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7792                                 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));
7793                         }
7794                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7795                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7796                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7797                 }
7798                 if (r->server_dn) {
7799                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7800                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7801                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7802                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7803                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7804                                 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));
7805                         }
7806                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7807                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7808                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7809                 }
7810                 if (r->ntds_dn) {
7811                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7812                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7813                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7814                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7815                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7816                                 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));
7817                         }
7818                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7819                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7820                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7821                 }
7822         }
7823         return NDR_ERR_SUCCESS;
7824 }
7825
7826 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo3 *r)
7827 {
7828         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo3");
7829         ndr->depth++;
7830         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7831         ndr->depth++;
7832         if (r->netbios_name) {
7833                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7834         }
7835         ndr->depth--;
7836         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7837         ndr->depth++;
7838         if (r->dns_name) {
7839                 ndr_print_string(ndr, "dns_name", r->dns_name);
7840         }
7841         ndr->depth--;
7842         ndr_print_ptr(ndr, "site_name", r->site_name);
7843         ndr->depth++;
7844         if (r->site_name) {
7845                 ndr_print_string(ndr, "site_name", r->site_name);
7846         }
7847         ndr->depth--;
7848         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7849         ndr->depth++;
7850         if (r->site_dn) {
7851                 ndr_print_string(ndr, "site_dn", r->site_dn);
7852         }
7853         ndr->depth--;
7854         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7855         ndr->depth++;
7856         if (r->computer_dn) {
7857                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7858         }
7859         ndr->depth--;
7860         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7861         ndr->depth++;
7862         if (r->server_dn) {
7863                 ndr_print_string(ndr, "server_dn", r->server_dn);
7864         }
7865         ndr->depth--;
7866         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7867         ndr->depth++;
7868         if (r->ntds_dn) {
7869                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7870         }
7871         ndr->depth--;
7872         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7873         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7874         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7875         ndr_print_uint32(ndr, "is_rodc", r->is_rodc);
7876         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7877         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7878         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7879         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7880         ndr->depth--;
7881 }
7882
7883 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr3 *r)
7884 {
7885         uint32_t cntr_array_1;
7886         if (ndr_flags & NDR_SCALARS) {
7887                 NDR_CHECK(ndr_push_align(ndr, 5));
7888                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7889                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7890                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7891         }
7892         if (ndr_flags & NDR_BUFFERS) {
7893                 if (r->array) {
7894                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7895                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7896                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7897                         }
7898                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7899                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7900                         }
7901                 }
7902         }
7903         return NDR_ERR_SUCCESS;
7904 }
7905
7906 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr3 *r)
7907 {
7908         uint32_t _ptr_array;
7909         uint32_t cntr_array_1;
7910         TALLOC_CTX *_mem_save_array_0;
7911         TALLOC_CTX *_mem_save_array_1;
7912         if (ndr_flags & NDR_SCALARS) {
7913                 NDR_CHECK(ndr_pull_align(ndr, 5));
7914                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7915                 if (r->count > 10000) {
7916                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7917                 }
7918                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7919                 if (_ptr_array) {
7920                         NDR_PULL_ALLOC(ndr, r->array);
7921                 } else {
7922                         r->array = NULL;
7923                 }
7924                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7925         }
7926         if (ndr_flags & NDR_BUFFERS) {
7927                 if (r->array) {
7928                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7929                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7930                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7931                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7932                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7933                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7934                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7935                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7936                         }
7937                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7938                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7939                         }
7940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7941                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7942                 }
7943                 if (r->array) {
7944                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7945                 }
7946         }
7947         return NDR_ERR_SUCCESS;
7948 }
7949
7950 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr3 *r)
7951 {
7952         uint32_t cntr_array_1;
7953         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr3");
7954         ndr->depth++;
7955         ndr_print_uint32(ndr, "count", r->count);
7956         ndr_print_ptr(ndr, "array", r->array);
7957         ndr->depth++;
7958         if (r->array) {
7959                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7960                 ndr->depth++;
7961                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7962                         char *idx_1=NULL;
7963                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7964                                 ndr_print_drsuapi_DsGetDCInfo3(ndr, "array", &r->array[cntr_array_1]);
7965                                 free(idx_1);
7966                         }
7967                 }
7968                 ndr->depth--;
7969         }
7970         ndr->depth--;
7971         ndr->depth--;
7972 }
7973
7974 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnection01 *r)
7975 {
7976         if (ndr_flags & NDR_SCALARS) {
7977                 NDR_CHECK(ndr_push_align(ndr, 5));
7978                 {
7979                         uint32_t _flags_save_ipv4address = ndr->flags;
7980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
7981                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
7982                         ndr->flags = _flags_save_ipv4address;
7983                 }
7984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
7985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connection_time));
7986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
7987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
7988                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
7989                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
7990                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7991         }
7992         if (ndr_flags & NDR_BUFFERS) {
7993                 if (r->client_account) {
7994                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7995                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7996                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7997                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_account, ndr_charset_length(r->client_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7998                 }
7999         }
8000         return NDR_ERR_SUCCESS;
8001 }
8002
8003 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnection01 *r)
8004 {
8005         uint32_t _ptr_client_account;
8006         TALLOC_CTX *_mem_save_client_account_0;
8007         if (ndr_flags & NDR_SCALARS) {
8008                 NDR_CHECK(ndr_pull_align(ndr, 5));
8009                 {
8010                         uint32_t _flags_save_ipv4address = ndr->flags;
8011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
8012                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
8013                         ndr->flags = _flags_save_ipv4address;
8014                 }
8015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connection_time));
8017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
8018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
8019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
8020                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_account));
8021                 if (_ptr_client_account) {
8022                         NDR_PULL_ALLOC(ndr, r->client_account);
8023                 } else {
8024                         r->client_account = NULL;
8025                 }
8026                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8027         }
8028         if (ndr_flags & NDR_BUFFERS) {
8029                 if (r->client_account) {
8030                         _mem_save_client_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8031                         NDR_PULL_SET_MEM_CTX(ndr, r->client_account, 0);
8032                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_account));
8033                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_account));
8034                         if (ndr_get_array_length(ndr, &r->client_account) > ndr_get_array_size(ndr, &r->client_account)) {
8035                                 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));
8036                         }
8037                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t)));
8038                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t), CH_UTF16));
8039                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_account_0, 0);
8040                 }
8041         }
8042         return NDR_ERR_SUCCESS;
8043 }
8044
8045 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnection01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnection01 *r)
8046 {
8047         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnection01");
8048         ndr->depth++;
8049         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
8050         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8051         ndr_print_uint32(ndr, "connection_time", r->connection_time);
8052         ndr_print_uint32(ndr, "unknown4", r->unknown4);
8053         ndr_print_uint32(ndr, "unknown5", r->unknown5);
8054         ndr_print_uint32(ndr, "unknown6", r->unknown6);
8055         ndr_print_ptr(ndr, "client_account", r->client_account);
8056         ndr->depth++;
8057         if (r->client_account) {
8058                 ndr_print_string(ndr, "client_account", r->client_account);
8059         }
8060         ndr->depth--;
8061         ndr->depth--;
8062 }
8063
8064 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8065 {
8066         uint32_t cntr_array_1;
8067         if (ndr_flags & NDR_SCALARS) {
8068                 NDR_CHECK(ndr_push_align(ndr, 5));
8069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8070                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
8071                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8072         }
8073         if (ndr_flags & NDR_BUFFERS) {
8074                 if (r->array) {
8075                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
8076                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8077                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8078                         }
8079                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8080                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8081                         }
8082                 }
8083         }
8084         return NDR_ERR_SUCCESS;
8085 }
8086
8087 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnectionCtr01 *r)
8088 {
8089         uint32_t _ptr_array;
8090         uint32_t cntr_array_1;
8091         TALLOC_CTX *_mem_save_array_0;
8092         TALLOC_CTX *_mem_save_array_1;
8093         if (ndr_flags & NDR_SCALARS) {
8094                 NDR_CHECK(ndr_pull_align(ndr, 5));
8095                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8096                 if (r->count > 10000) {
8097                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8098                 }
8099                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
8100                 if (_ptr_array) {
8101                         NDR_PULL_ALLOC(ndr, r->array);
8102                 } else {
8103                         r->array = NULL;
8104                 }
8105                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8106         }
8107         if (ndr_flags & NDR_BUFFERS) {
8108                 if (r->array) {
8109                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
8110                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8111                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
8112                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
8113                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
8114                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8115                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8116                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8117                         }
8118                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8119                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8120                         }
8121                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
8122                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
8123                 }
8124                 if (r->array) {
8125                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
8126                 }
8127         }
8128         return NDR_ERR_SUCCESS;
8129 }
8130
8131 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnectionCtr01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8132 {
8133         uint32_t cntr_array_1;
8134         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnectionCtr01");
8135         ndr->depth++;
8136         ndr_print_uint32(ndr, "count", r->count);
8137         ndr_print_ptr(ndr, "array", r->array);
8138         ndr->depth++;
8139         if (r->array) {
8140                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
8141                 ndr->depth++;
8142                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
8143                         char *idx_1=NULL;
8144                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8145                                 ndr_print_drsuapi_DsGetDCConnection01(ndr, "array", &r->array[cntr_array_1]);
8146                                 free(idx_1);
8147                         }
8148                 }
8149                 ndr->depth--;
8150         }
8151         ndr->depth--;
8152         ndr->depth--;
8153 }
8154
8155 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoCtr *r)
8156 {
8157         if (ndr_flags & NDR_SCALARS) {
8158                 int level = ndr_push_get_switch_value(ndr, r);
8159                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8160                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8161                 switch (level) {
8162                         case DRSUAPI_DC_INFO_CTR_1: {
8163                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8164                         break; }
8165
8166                         case DRSUAPI_DC_INFO_CTR_2: {
8167                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8168                         break; }
8169
8170                         case DRSUAPI_DC_INFO_CTR_3: {
8171                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8172                         break; }
8173
8174                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8175                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8176                         break; }
8177
8178                         default:
8179                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8180                 }
8181         }
8182         if (ndr_flags & NDR_BUFFERS) {
8183                 int level = ndr_push_get_switch_value(ndr, r);
8184                 switch (level) {
8185                         case DRSUAPI_DC_INFO_CTR_1:
8186                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8187                         break;
8188
8189                         case DRSUAPI_DC_INFO_CTR_2:
8190                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8191                         break;
8192
8193                         case DRSUAPI_DC_INFO_CTR_3:
8194                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8195                         break;
8196
8197                         case DRSUAPI_DC_CONNECTION_CTR_01:
8198                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8199                         break;
8200
8201                         default:
8202                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8203                 }
8204         }
8205         return NDR_ERR_SUCCESS;
8206 }
8207
8208 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoCtr *r)
8209 {
8210         int level;
8211         int32_t _level;
8212         level = ndr_pull_get_switch_value(ndr, r);
8213         if (ndr_flags & NDR_SCALARS) {
8214                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8215                 if (_level != level) {
8216                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8217                 }
8218                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8219                 switch (level) {
8220                         case DRSUAPI_DC_INFO_CTR_1: {
8221                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8222                         break; }
8223
8224                         case DRSUAPI_DC_INFO_CTR_2: {
8225                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8226                         break; }
8227
8228                         case DRSUAPI_DC_INFO_CTR_3: {
8229                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8230                         break; }
8231
8232                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8233                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8234                         break; }
8235
8236                         default:
8237                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8238                 }
8239         }
8240         if (ndr_flags & NDR_BUFFERS) {
8241                 switch (level) {
8242                         case DRSUAPI_DC_INFO_CTR_1:
8243                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8244                         break;
8245
8246                         case DRSUAPI_DC_INFO_CTR_2:
8247                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8248                         break;
8249
8250                         case DRSUAPI_DC_INFO_CTR_3:
8251                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8252                         break;
8253
8254                         case DRSUAPI_DC_CONNECTION_CTR_01:
8255                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8256                         break;
8257
8258                         default:
8259                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8260                 }
8261         }
8262         return NDR_ERR_SUCCESS;
8263 }
8264
8265 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoCtr *r)
8266 {
8267         int level;
8268         level = ndr_print_get_switch_value(ndr, r);
8269         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoCtr");
8270         switch (level) {
8271                 case DRSUAPI_DC_INFO_CTR_1:
8272                         ndr_print_drsuapi_DsGetDCInfoCtr1(ndr, "ctr1", &r->ctr1);
8273                 break;
8274
8275                 case DRSUAPI_DC_INFO_CTR_2:
8276                         ndr_print_drsuapi_DsGetDCInfoCtr2(ndr, "ctr2", &r->ctr2);
8277                 break;
8278
8279                 case DRSUAPI_DC_INFO_CTR_3:
8280                         ndr_print_drsuapi_DsGetDCInfoCtr3(ndr, "ctr3", &r->ctr3);
8281                 break;
8282
8283                 case DRSUAPI_DC_CONNECTION_CTR_01:
8284                         ndr_print_drsuapi_DsGetDCConnectionCtr01(ndr, "ctr01", &r->ctr01);
8285                 break;
8286
8287                 default:
8288                         ndr_print_bad_level(ndr, name, level);
8289         }
8290 }
8291
8292 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItem *r)
8293 {
8294         if (ndr_flags & NDR_SCALARS) {
8295                 NDR_CHECK(ndr_push_align(ndr, 5));
8296                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
8297                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8298                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8299         }
8300         if (ndr_flags & NDR_BUFFERS) {
8301                 if (r->next_object) {
8302                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8303                 }
8304                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8305         }
8306         return NDR_ERR_SUCCESS;
8307 }
8308
8309 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItem *r)
8310 {
8311         uint32_t _ptr_next_object;
8312         TALLOC_CTX *_mem_save_next_object_0;
8313         if (ndr_flags & NDR_SCALARS) {
8314                 NDR_CHECK(ndr_pull_align(ndr, 5));
8315                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
8316                 if (_ptr_next_object) {
8317                         NDR_PULL_ALLOC(ndr, r->next_object);
8318                 } else {
8319                         r->next_object = NULL;
8320                 }
8321                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8322                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8323         }
8324         if (ndr_flags & NDR_BUFFERS) {
8325                 if (r->next_object) {
8326                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
8327                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
8328                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8329                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
8330                 }
8331                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8332         }
8333         return NDR_ERR_SUCCESS;
8334 }
8335
8336 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryRequest2 *r)
8337 {
8338         if (ndr_flags & NDR_SCALARS) {
8339                 NDR_CHECK(ndr_push_align(ndr, 5));
8340                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8341                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8342         }
8343         if (ndr_flags & NDR_BUFFERS) {
8344                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8345         }
8346         return NDR_ERR_SUCCESS;
8347 }
8348
8349 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryRequest2 *r)
8350 {
8351         if (ndr_flags & NDR_SCALARS) {
8352                 NDR_CHECK(ndr_pull_align(ndr, 5));
8353                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8354                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8355         }
8356         if (ndr_flags & NDR_BUFFERS) {
8357                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8358         }
8359         return NDR_ERR_SUCCESS;
8360 }
8361
8362 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryRequest2 *r)
8363 {
8364         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryRequest2");
8365         ndr->depth++;
8366         ndr_print_drsuapi_DsReplicaObjectListItem(ndr, "first_object", &r->first_object);
8367         ndr->depth--;
8368 }
8369
8370 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryRequest *r)
8371 {
8372         if (ndr_flags & NDR_SCALARS) {
8373                 int level = ndr_push_get_switch_value(ndr, r);
8374                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8375                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8376                 switch (level) {
8377                         case 2: {
8378                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8379                         break; }
8380
8381                         default:
8382                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8383                 }
8384         }
8385         if (ndr_flags & NDR_BUFFERS) {
8386                 int level = ndr_push_get_switch_value(ndr, r);
8387                 switch (level) {
8388                         case 2:
8389                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8390                         break;
8391
8392                         default:
8393                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8394                 }
8395         }
8396         return NDR_ERR_SUCCESS;
8397 }
8398
8399 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryRequest *r)
8400 {
8401         int level;
8402         int32_t _level;
8403         level = ndr_pull_get_switch_value(ndr, r);
8404         if (ndr_flags & NDR_SCALARS) {
8405                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8406                 if (_level != level) {
8407                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8408                 }
8409                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8410                 switch (level) {
8411                         case 2: {
8412                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8413                         break; }
8414
8415                         default:
8416                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8417                 }
8418         }
8419         if (ndr_flags & NDR_BUFFERS) {
8420                 switch (level) {
8421                         case 2:
8422                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8423                         break;
8424
8425                         default:
8426                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8427                 }
8428         }
8429         return NDR_ERR_SUCCESS;
8430 }
8431
8432 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryRequest *r)
8433 {
8434         int level;
8435         level = ndr_print_get_switch_value(ndr, r);
8436         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryRequest");
8437         switch (level) {
8438                 case 2:
8439                         ndr_print_drsuapi_DsAddEntryRequest2(ndr, "req2", &r->req2);
8440                 break;
8441
8442                 default:
8443                         ndr_print_bad_level(ndr, name, level);
8444         }
8445 }
8446
8447 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfoX *r)
8448 {
8449         if (ndr_flags & NDR_SCALARS) {
8450                 NDR_CHECK(ndr_push_align(ndr, 4));
8451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8452                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8453                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8454                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
8455                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8456         }
8457         if (ndr_flags & NDR_BUFFERS) {
8458         }
8459         return NDR_ERR_SUCCESS;
8460 }
8461
8462 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfoX *r)
8463 {
8464         if (ndr_flags & NDR_SCALARS) {
8465                 NDR_CHECK(ndr_pull_align(ndr, 4));
8466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8467                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8468                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8469                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
8470                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8471         }
8472         if (ndr_flags & NDR_BUFFERS) {
8473         }
8474         return NDR_ERR_SUCCESS;
8475 }
8476
8477 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfoX(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfoX *r)
8478 {
8479         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfoX");
8480         ndr->depth++;
8481         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8482         ndr_print_WERROR(ndr, "status", r->status);
8483         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8484         ndr_print_uint16(ndr, "unknown3", r->unknown3);
8485         ndr->depth--;
8486 }
8487
8488 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8489 {
8490         if (ndr_flags & NDR_SCALARS) {
8491                 NDR_CHECK(ndr_push_align(ndr, 5));
8492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8493                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
8494                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8495         }
8496         if (ndr_flags & NDR_BUFFERS) {
8497                 if (r->data) {
8498                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size));
8499                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
8500                 }
8501         }
8502         return NDR_ERR_SUCCESS;
8503 }
8504
8505 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8506 {
8507         uint32_t _ptr_data;
8508         TALLOC_CTX *_mem_save_data_0;
8509         if (ndr_flags & NDR_SCALARS) {
8510                 NDR_CHECK(ndr_pull_align(ndr, 5));
8511                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8512                 if (r->size > 10485760) {
8513                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8514                 }
8515                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
8516                 if (_ptr_data) {
8517                         NDR_PULL_ALLOC(ndr, r->data);
8518                 } else {
8519                         r->data = NULL;
8520                 }
8521                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8522         }
8523         if (ndr_flags & NDR_BUFFERS) {
8524                 if (r->data) {
8525                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
8526                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
8527                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
8528                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
8529                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
8530                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
8531                 }
8532                 if (r->data) {
8533                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
8534                 }
8535         }
8536         return NDR_ERR_SUCCESS;
8537 }
8538
8539 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8540 {
8541         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraErrorBuffer");
8542         ndr->depth++;
8543         ndr_print_uint32(ndr, "size", r->size);
8544         ndr_print_ptr(ndr, "data", r->data);
8545         ndr->depth++;
8546         if (r->data) {
8547                 ndr_print_array_uint8(ndr, "data", r->data, r->size);
8548         }
8549         ndr->depth--;
8550         ndr->depth--;
8551 }
8552
8553 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraError1 *r)
8554 {
8555         if (ndr_flags & NDR_SCALARS) {
8556                 NDR_CHECK(ndr_push_align(ndr, 5));
8557                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8558                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
8559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8560                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8561                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8562         }
8563         if (ndr_flags & NDR_BUFFERS) {
8564                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8565         }
8566         return NDR_ERR_SUCCESS;
8567 }
8568
8569 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraError1 *r)
8570 {
8571         if (ndr_flags & NDR_SCALARS) {
8572                 NDR_CHECK(ndr_pull_align(ndr, 5));
8573                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8574                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
8575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8576                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8577                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8578         }
8579         if (ndr_flags & NDR_BUFFERS) {
8580                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8581         }
8582         return NDR_ERR_SUCCESS;
8583 }
8584
8585 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraError1 *r)
8586 {
8587         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraError1");
8588         ndr->depth++;
8589         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8590         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
8591         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8592         ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(ndr, "buffer", &r->buffer);
8593         ndr->depth--;
8594 }
8595
8596 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8597 {
8598         if (ndr_flags & NDR_SCALARS) {
8599                 NDR_CHECK(ndr_push_align(ndr, 5));
8600                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
8601                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8602                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8603         }
8604         if (ndr_flags & NDR_BUFFERS) {
8605                 if (r->next) {
8606                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8607                 }
8608                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8609         }
8610         return NDR_ERR_SUCCESS;
8611 }
8612
8613 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorListItem1 *r)
8614 {
8615         uint32_t _ptr_next;
8616         TALLOC_CTX *_mem_save_next_0;
8617         if (ndr_flags & NDR_SCALARS) {
8618                 NDR_CHECK(ndr_pull_align(ndr, 5));
8619                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
8620                 if (_ptr_next) {
8621                         NDR_PULL_ALLOC(ndr, r->next);
8622                 } else {
8623                         r->next = NULL;
8624                 }
8625                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8626                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8627         }
8628         if (ndr_flags & NDR_BUFFERS) {
8629                 if (r->next) {
8630                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
8631                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
8632                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8633                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
8634                 }
8635                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8636         }
8637         return NDR_ERR_SUCCESS;
8638 }
8639
8640 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorListItem1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8641 {
8642         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorListItem1");
8643         ndr->depth++;
8644         ndr_print_ptr(ndr, "next", r->next);
8645         ndr->depth++;
8646         if (r->next) {
8647                 ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "next", r->next);
8648         }
8649         ndr->depth--;
8650         ndr_print_drsuapi_DsAddEntryExtraError1(ndr, "error", &r->error);
8651         ndr->depth--;
8652 }
8653
8654 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8655 {
8656         if (ndr_flags & NDR_SCALARS) {
8657                 NDR_CHECK(ndr_push_align(ndr, 5));
8658                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8659                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8660                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8661                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8662         }
8663         if (ndr_flags & NDR_BUFFERS) {
8664                 if (r->id) {
8665                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8666                 }
8667                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8668         }
8669         return NDR_ERR_SUCCESS;
8670 }
8671
8672 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfo1 *r)
8673 {
8674         uint32_t _ptr_id;
8675         TALLOC_CTX *_mem_save_id_0;
8676         if (ndr_flags & NDR_SCALARS) {
8677                 NDR_CHECK(ndr_pull_align(ndr, 5));
8678                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8679                 if (_ptr_id) {
8680                         NDR_PULL_ALLOC(ndr, r->id);
8681                 } else {
8682                         r->id = NULL;
8683                 }
8684                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8685                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8686                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8687         }
8688         if (ndr_flags & NDR_BUFFERS) {
8689                 if (r->id) {
8690                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8691                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8692                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8693                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8694                 }
8695                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8696         }
8697         return NDR_ERR_SUCCESS;
8698 }
8699
8700 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8701 {
8702         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfo1");
8703         ndr->depth++;
8704         ndr_print_ptr(ndr, "id", r->id);
8705         ndr->depth++;
8706         if (r->id) {
8707                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8708         }
8709         ndr->depth--;
8710         ndr_print_WERROR(ndr, "status", r->status);
8711         ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "first", &r->first);
8712         ndr->depth--;
8713 }
8714
8715 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryErrorInfo *r)
8716 {
8717         if (ndr_flags & NDR_SCALARS) {
8718                 int level = ndr_push_get_switch_value(ndr, r);
8719                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8720                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8721                 switch (level) {
8722                         case 1: {
8723                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8724                         break; }
8725
8726                         case 4: {
8727                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8728                         break; }
8729
8730                         case 5: {
8731                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8732                         break; }
8733
8734                         case 6: {
8735                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8736                         break; }
8737
8738                         case 7: {
8739                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8740                         break; }
8741
8742                         default:
8743                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8744                 }
8745         }
8746         if (ndr_flags & NDR_BUFFERS) {
8747                 int level = ndr_push_get_switch_value(ndr, r);
8748                 switch (level) {
8749                         case 1:
8750                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8751                         break;
8752
8753                         case 4:
8754                         break;
8755
8756                         case 5:
8757                         break;
8758
8759                         case 6:
8760                         break;
8761
8762                         case 7:
8763                         break;
8764
8765                         default:
8766                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8767                 }
8768         }
8769         return NDR_ERR_SUCCESS;
8770 }
8771
8772 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryErrorInfo *r)
8773 {
8774         int level;
8775         uint32_t _level;
8776         level = ndr_pull_get_switch_value(ndr, r);
8777         if (ndr_flags & NDR_SCALARS) {
8778                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8779                 if (_level != level) {
8780                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8781                 }
8782                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8783                 switch (level) {
8784                         case 1: {
8785                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8786                         break; }
8787
8788                         case 4: {
8789                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8790                         break; }
8791
8792                         case 5: {
8793                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8794                         break; }
8795
8796                         case 6: {
8797                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8798                         break; }
8799
8800                         case 7: {
8801                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8802                         break; }
8803
8804                         default:
8805                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8806                 }
8807         }
8808         if (ndr_flags & NDR_BUFFERS) {
8809                 switch (level) {
8810                         case 1:
8811                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8812                         break;
8813
8814                         case 4:
8815                         break;
8816
8817                         case 5:
8818                         break;
8819
8820                         case 6:
8821                         break;
8822
8823                         case 7:
8824                         break;
8825
8826                         default:
8827                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8828                 }
8829         }
8830         return NDR_ERR_SUCCESS;
8831 }
8832
8833 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryErrorInfo *r)
8834 {
8835         int level;
8836         level = ndr_print_get_switch_value(ndr, r);
8837         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryErrorInfo");
8838         switch (level) {
8839                 case 1:
8840                         ndr_print_drsuapi_DsAddEntryErrorInfo1(ndr, "error1", &r->error1);
8841                 break;
8842
8843                 case 4:
8844                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8845                 break;
8846
8847                 case 5:
8848                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8849                 break;
8850
8851                 case 6:
8852                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8853                 break;
8854
8855                 case 7:
8856                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8857                 break;
8858
8859                 default:
8860                         ndr_print_bad_level(ndr, name, level);
8861         }
8862 }
8863
8864 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryError1 *r)
8865 {
8866         if (ndr_flags & NDR_SCALARS) {
8867                 NDR_CHECK(ndr_push_align(ndr, 5));
8868                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8870                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
8871                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8872         }
8873         if (ndr_flags & NDR_BUFFERS) {
8874                 if (r->info) {
8875                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->info, r->level));
8876                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8877                 }
8878         }
8879         return NDR_ERR_SUCCESS;
8880 }
8881
8882 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryError1 *r)
8883 {
8884         uint32_t _ptr_info;
8885         TALLOC_CTX *_mem_save_info_0;
8886         if (ndr_flags & NDR_SCALARS) {
8887                 NDR_CHECK(ndr_pull_align(ndr, 5));
8888                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8890                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8891                 if (_ptr_info) {
8892                         NDR_PULL_ALLOC(ndr, r->info);
8893                 } else {
8894                         r->info = NULL;
8895                 }
8896                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8897         }
8898         if (ndr_flags & NDR_BUFFERS) {
8899                 if (r->info) {
8900                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8901                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
8902                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->info, r->level));
8903                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8904                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8905                 }
8906         }
8907         return NDR_ERR_SUCCESS;
8908 }
8909
8910 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryError1 *r)
8911 {
8912         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryError1");
8913         ndr->depth++;
8914         ndr_print_WERROR(ndr, "status", r->status);
8915         ndr_print_uint32(ndr, "level", r->level);
8916         ndr_print_ptr(ndr, "info", r->info);
8917         ndr->depth++;
8918         if (r->info) {
8919                 ndr_print_set_switch_value(ndr, r->info, r->level);
8920                 ndr_print_drsuapi_DsAddEntryErrorInfo(ndr, "info", r->info);
8921         }
8922         ndr->depth--;
8923         ndr->depth--;
8924 }
8925
8926 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryError *r)
8927 {
8928         if (ndr_flags & NDR_SCALARS) {
8929                 int level = ndr_push_get_switch_value(ndr, r);
8930                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8931                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8932                 switch (level) {
8933                         case 1: {
8934                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8935                         break; }
8936
8937                         default:
8938                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8939                 }
8940         }
8941         if (ndr_flags & NDR_BUFFERS) {
8942                 int level = ndr_push_get_switch_value(ndr, r);
8943                 switch (level) {
8944                         case 1:
8945                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8946                         break;
8947
8948                         default:
8949                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8950                 }
8951         }
8952         return NDR_ERR_SUCCESS;
8953 }
8954
8955 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryError *r)
8956 {
8957         int level;
8958         uint32_t _level;
8959         level = ndr_pull_get_switch_value(ndr, r);
8960         if (ndr_flags & NDR_SCALARS) {
8961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8962                 if (_level != level) {
8963                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8964                 }
8965                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8966                 switch (level) {
8967                         case 1: {
8968                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8969                         break; }
8970
8971                         default:
8972                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8973                 }
8974         }
8975         if (ndr_flags & NDR_BUFFERS) {
8976                 switch (level) {
8977                         case 1:
8978                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8979                         break;
8980
8981                         default:
8982                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8983                 }
8984         }
8985         return NDR_ERR_SUCCESS;
8986 }
8987
8988 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryError *r)
8989 {
8990         int level;
8991         level = ndr_print_get_switch_value(ndr, r);
8992         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryError");
8993         switch (level) {
8994                 case 1:
8995                         ndr_print_drsuapi_DsAddEntryError1(ndr, "info1", &r->info1);
8996                 break;
8997
8998                 default:
8999                         ndr_print_bad_level(ndr, name, level);
9000         }
9001 }
9002
9003 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9004 {
9005         if (ndr_flags & NDR_SCALARS) {
9006                 NDR_CHECK(ndr_push_align(ndr, 4));
9007                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
9008                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9009                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9010         }
9011         if (ndr_flags & NDR_BUFFERS) {
9012                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9013         }
9014         return NDR_ERR_SUCCESS;
9015 }
9016
9017 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier2 *r)
9018 {
9019         if (ndr_flags & NDR_SCALARS) {
9020                 NDR_CHECK(ndr_pull_align(ndr, 4));
9021                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
9022                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9023                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9024         }
9025         if (ndr_flags & NDR_BUFFERS) {
9026                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9027         }
9028         return NDR_ERR_SUCCESS;
9029 }
9030
9031 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9032 {
9033         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier2");
9034         ndr->depth++;
9035         ndr_print_GUID(ndr, "guid", &r->guid);
9036         ndr_print_dom_sid28(ndr, "sid", &r->sid);
9037         ndr->depth--;
9038 }
9039
9040 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr2 *r)
9041 {
9042         uint32_t cntr_objects_1;
9043         if (ndr_flags & NDR_SCALARS) {
9044                 NDR_CHECK(ndr_push_align(ndr, 5));
9045                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9047                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9048                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9049                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9050                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9051         }
9052         if (ndr_flags & NDR_BUFFERS) {
9053                 if (r->id) {
9054                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9055                 }
9056                 if (r->objects) {
9057                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9058                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9059                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9060                         }
9061                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9062                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9063                         }
9064                 }
9065         }
9066         return NDR_ERR_SUCCESS;
9067 }
9068
9069 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr2 *r)
9070 {
9071         uint32_t _ptr_id;
9072         TALLOC_CTX *_mem_save_id_0;
9073         uint32_t _ptr_objects;
9074         uint32_t cntr_objects_1;
9075         TALLOC_CTX *_mem_save_objects_0;
9076         TALLOC_CTX *_mem_save_objects_1;
9077         if (ndr_flags & NDR_SCALARS) {
9078                 NDR_CHECK(ndr_pull_align(ndr, 5));
9079                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9080                 if (_ptr_id) {
9081                         NDR_PULL_ALLOC(ndr, r->id);
9082                 } else {
9083                         r->id = NULL;
9084                 }
9085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9086                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9087                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9088                 if (r->count > 10000) {
9089                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9090                 }
9091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9092                 if (_ptr_objects) {
9093                         NDR_PULL_ALLOC(ndr, r->objects);
9094                 } else {
9095                         r->objects = NULL;
9096                 }
9097                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9098         }
9099         if (ndr_flags & NDR_BUFFERS) {
9100                 if (r->id) {
9101                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9102                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9103                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9105                 }
9106                 if (r->objects) {
9107                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9108                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9109                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9110                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9111                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9112                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9113                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9114                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9115                         }
9116                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9117                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9118                         }
9119                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9120                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9121                 }
9122                 if (r->objects) {
9123                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9124                 }
9125         }
9126         return NDR_ERR_SUCCESS;
9127 }
9128
9129 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr2 *r)
9130 {
9131         uint32_t cntr_objects_1;
9132         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr2");
9133         ndr->depth++;
9134         ndr_print_ptr(ndr, "id", r->id);
9135         ndr->depth++;
9136         if (r->id) {
9137                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9138         }
9139         ndr->depth--;
9140         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9141         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
9142         ndr_print_uint32(ndr, "count", r->count);
9143         ndr_print_ptr(ndr, "objects", r->objects);
9144         ndr->depth++;
9145         if (r->objects) {
9146                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9147                 ndr->depth++;
9148                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9149                         char *idx_1=NULL;
9150                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9151                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9152                                 free(idx_1);
9153                         }
9154                 }
9155                 ndr->depth--;
9156         }
9157         ndr->depth--;
9158         ndr->depth--;
9159 }
9160
9161 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr3 *r)
9162 {
9163         uint32_t cntr_objects_1;
9164         if (ndr_flags & NDR_SCALARS) {
9165                 NDR_CHECK(ndr_push_align(ndr, 5));
9166                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9168                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
9169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9170                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9171                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9172         }
9173         if (ndr_flags & NDR_BUFFERS) {
9174                 if (r->id) {
9175                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9176                 }
9177                 if (r->error) {
9178                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->error, r->level));
9179                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9180                 }
9181                 if (r->objects) {
9182                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9183                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9184                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9185                         }
9186                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9187                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9188                         }
9189                 }
9190         }
9191         return NDR_ERR_SUCCESS;
9192 }
9193
9194 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr3 *r)
9195 {
9196         uint32_t _ptr_id;
9197         TALLOC_CTX *_mem_save_id_0;
9198         uint32_t _ptr_error;
9199         TALLOC_CTX *_mem_save_error_0;
9200         uint32_t _ptr_objects;
9201         uint32_t cntr_objects_1;
9202         TALLOC_CTX *_mem_save_objects_0;
9203         TALLOC_CTX *_mem_save_objects_1;
9204         if (ndr_flags & NDR_SCALARS) {
9205                 NDR_CHECK(ndr_pull_align(ndr, 5));
9206                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9207                 if (_ptr_id) {
9208                         NDR_PULL_ALLOC(ndr, r->id);
9209                 } else {
9210                         r->id = NULL;
9211                 }
9212                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9213                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_error));
9214                 if (_ptr_error) {
9215                         NDR_PULL_ALLOC(ndr, r->error);
9216                 } else {
9217                         r->error = NULL;
9218                 }
9219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9220                 if (r->count > 10000) {
9221                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9222                 }
9223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9224                 if (_ptr_objects) {
9225                         NDR_PULL_ALLOC(ndr, r->objects);
9226                 } else {
9227                         r->objects = NULL;
9228                 }
9229                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9230         }
9231         if (ndr_flags & NDR_BUFFERS) {
9232                 if (r->id) {
9233                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9234                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9235                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9236                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9237                 }
9238                 if (r->error) {
9239                         _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
9240                         NDR_PULL_SET_MEM_CTX(ndr, r->error, 0);
9241                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->error, r->level));
9242                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9243                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, 0);
9244                 }
9245                 if (r->objects) {
9246                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9247                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9248                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9249                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9250                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9251                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9252                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9253                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9254                         }
9255                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9256                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9257                         }
9258                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9259                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9260                 }
9261                 if (r->objects) {
9262                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9263                 }
9264         }
9265         return NDR_ERR_SUCCESS;
9266 }
9267
9268 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr3 *r)
9269 {
9270         uint32_t cntr_objects_1;
9271         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr3");
9272         ndr->depth++;
9273         ndr_print_ptr(ndr, "id", r->id);
9274         ndr->depth++;
9275         if (r->id) {
9276                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9277         }
9278         ndr->depth--;
9279         ndr_print_uint32(ndr, "level", r->level);
9280         ndr_print_ptr(ndr, "error", r->error);
9281         ndr->depth++;
9282         if (r->error) {
9283                 ndr_print_set_switch_value(ndr, r->error, r->level);
9284                 ndr_print_drsuapi_DsAddEntryError(ndr, "error", r->error);
9285         }
9286         ndr->depth--;
9287         ndr_print_uint32(ndr, "count", r->count);
9288         ndr_print_ptr(ndr, "objects", r->objects);
9289         ndr->depth++;
9290         if (r->objects) {
9291                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9292                 ndr->depth++;
9293                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9294                         char *idx_1=NULL;
9295                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9296                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9297                                 free(idx_1);
9298                         }
9299                 }
9300                 ndr->depth--;
9301         }
9302         ndr->depth--;
9303         ndr->depth--;
9304 }
9305
9306 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryCtr *r)
9307 {
9308         if (ndr_flags & NDR_SCALARS) {
9309                 int level = ndr_push_get_switch_value(ndr, r);
9310                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
9311                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9312                 switch (level) {
9313                         case 2: {
9314                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9315                         break; }
9316
9317                         case 3: {
9318                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9319                         break; }
9320
9321                         default:
9322                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9323                 }
9324         }
9325         if (ndr_flags & NDR_BUFFERS) {
9326                 int level = ndr_push_get_switch_value(ndr, r);
9327                 switch (level) {
9328                         case 2:
9329                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9330                         break;
9331
9332                         case 3:
9333                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9334                         break;
9335
9336                         default:
9337                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9338                 }
9339         }
9340         return NDR_ERR_SUCCESS;
9341 }
9342
9343 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryCtr *r)
9344 {
9345         int level;
9346         int32_t _level;
9347         level = ndr_pull_get_switch_value(ndr, r);
9348         if (ndr_flags & NDR_SCALARS) {
9349                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
9350                 if (_level != level) {
9351                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9352                 }
9353                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9354                 switch (level) {
9355                         case 2: {
9356                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9357                         break; }
9358
9359                         case 3: {
9360                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9361                         break; }
9362
9363                         default:
9364                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9365                 }
9366         }
9367         if (ndr_flags & NDR_BUFFERS) {
9368                 switch (level) {
9369                         case 2:
9370                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9371                         break;
9372
9373                         case 3:
9374                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9375                         break;
9376
9377                         default:
9378                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9379                 }
9380         }
9381         return NDR_ERR_SUCCESS;
9382 }
9383
9384 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
9385 {
9386         int level;
9387         level = ndr_print_get_switch_value(ndr, r);
9388         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
9389         switch (level) {
9390                 case 2:
9391                         ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
9392                 break;
9393
9394                 case 3:
9395                         ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
9396                 break;
9397
9398                 default:
9399                         ndr_print_bad_level(ndr, name, level);
9400         }
9401 }
9402
9403 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9404 {
9405         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9406         return NDR_ERR_SUCCESS;
9407 }
9408
9409 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9410 {
9411         uint32_t v;
9412         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9413         *r = v;
9414         return NDR_ERR_SUCCESS;
9415 }
9416
9417 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCFlags(struct ndr_print *ndr, const char *name, uint32_t r)
9418 {
9419         ndr_print_uint32(ndr, name, r);
9420         ndr->depth++;
9421         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION, r);
9422         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_DAMPED", DRSUAPI_DS_EXECUTE_KCC_DAMPED, r);
9423         ndr->depth--;
9424 }
9425
9426 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsExecuteKCC1 *r)
9427 {
9428         if (ndr_flags & NDR_SCALARS) {
9429                 NDR_CHECK(ndr_push_align(ndr, 4));
9430                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->taskID));
9431                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, r->flags));
9432                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9433         }
9434         if (ndr_flags & NDR_BUFFERS) {
9435         }
9436         return NDR_ERR_SUCCESS;
9437 }
9438
9439 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsExecuteKCC1 *r)
9440 {
9441         if (ndr_flags & NDR_SCALARS) {
9442                 NDR_CHECK(ndr_pull_align(ndr, 4));
9443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->taskID));
9444                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, &r->flags));
9445                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9446         }
9447         if (ndr_flags & NDR_BUFFERS) {
9448         }
9449         return NDR_ERR_SUCCESS;
9450 }
9451
9452 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsExecuteKCC1 *r)
9453 {
9454         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC1");
9455         ndr->depth++;
9456         ndr_print_uint32(ndr, "taskID", r->taskID);
9457         ndr_print_drsuapi_DsExecuteKCCFlags(ndr, "flags", r->flags);
9458         ndr->depth--;
9459 }
9460
9461 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsExecuteKCCRequest *r)
9462 {
9463         if (ndr_flags & NDR_SCALARS) {
9464                 int level = ndr_push_get_switch_value(ndr, r);
9465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9466                 NDR_CHECK(ndr_push_union_align(ndr, 4));
9467                 switch (level) {
9468                         case 1: {
9469                                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9470                         break; }
9471
9472                         default:
9473                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9474                 }
9475         }
9476         if (ndr_flags & NDR_BUFFERS) {
9477                 int level = ndr_push_get_switch_value(ndr, r);
9478                 switch (level) {
9479                         case 1:
9480                         break;
9481
9482                         default:
9483                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9484                 }
9485         }
9486         return NDR_ERR_SUCCESS;
9487 }
9488
9489 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsExecuteKCCRequest *r)
9490 {
9491         int level;
9492         uint32_t _level;
9493         level = ndr_pull_get_switch_value(ndr, r);
9494         if (ndr_flags & NDR_SCALARS) {
9495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9496                 if (_level != level) {
9497                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9498                 }
9499                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
9500                 switch (level) {
9501                         case 1: {
9502                                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9503                         break; }
9504
9505                         default:
9506                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9507                 }
9508         }
9509         if (ndr_flags & NDR_BUFFERS) {
9510                 switch (level) {
9511                         case 1:
9512                         break;
9513
9514                         default:
9515                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9516                 }
9517         }
9518         return NDR_ERR_SUCCESS;
9519 }
9520
9521 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsExecuteKCCRequest *r)
9522 {
9523         int level;
9524         level = ndr_print_get_switch_value(ndr, r);
9525         ndr_print_union(ndr, name, level, "drsuapi_DsExecuteKCCRequest");
9526         switch (level) {
9527                 case 1:
9528                         ndr_print_drsuapi_DsExecuteKCC1(ndr, "ctr1", &r->ctr1);
9529                 break;
9530
9531                 default:
9532                         ndr_print_bad_level(ndr, name, level);
9533         }
9534 }
9535
9536 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
9537 {
9538         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9539         return NDR_ERR_SUCCESS;
9540 }
9541
9542 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
9543 {
9544         uint32_t v;
9545         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9546         *r = v;
9547         return NDR_ERR_SUCCESS;
9548 }
9549
9550 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaGetInfoLevel r)
9551 {
9552         const char *val = NULL;
9553
9554         switch (r) {
9555                 case DRSUAPI_DS_REPLICA_GET_INFO: val = "DRSUAPI_DS_REPLICA_GET_INFO"; break;
9556                 case DRSUAPI_DS_REPLICA_GET_INFO2: val = "DRSUAPI_DS_REPLICA_GET_INFO2"; break;
9557         }
9558         ndr_print_enum(ndr, name, "ENUM", val, r);
9559 }
9560
9561 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
9562 {
9563         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9564         return NDR_ERR_SUCCESS;
9565 }
9566
9567 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
9568 {
9569         uint32_t v;
9570         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9571         *r = v;
9572         return NDR_ERR_SUCCESS;
9573 }
9574
9575 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaInfoType r)
9576 {
9577         const char *val = NULL;
9578
9579         switch (r) {
9580                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS"; break;
9581                 case DRSUAPI_DS_REPLICA_INFO_CURSORS: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS"; break;
9582                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA"; break;
9583                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES"; break;
9584                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES"; break;
9585                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: val = "DRSUAPI_DS_REPLICA_INFO_PENDING_OPS"; break;
9586                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA"; break;
9587                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS2"; break;
9588                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS3"; break;
9589                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2"; break;
9590                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2"; break;
9591                 case DRSUAPI_DS_REPLICA_INFO_REPSTO: val = "DRSUAPI_DS_REPLICA_INFO_REPSTO"; break;
9592                 case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS: val = "DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS"; break;
9593                 case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1: val = "DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1"; break;
9594                 case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS: val = "DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS"; break;
9595         }
9596         ndr_print_enum(ndr, name, "ENUM", val, r);
9597 }
9598
9599 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9600 {
9601         if (ndr_flags & NDR_SCALARS) {
9602                 NDR_CHECK(ndr_push_align(ndr, 5));
9603                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9605                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9606                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9607         }
9608         if (ndr_flags & NDR_BUFFERS) {
9609                 if (r->object_dn) {
9610                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9611                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9612                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9613                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9614                 }
9615         }
9616         return NDR_ERR_SUCCESS;
9617 }
9618
9619 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
9620 {
9621         uint32_t _ptr_object_dn;
9622         TALLOC_CTX *_mem_save_object_dn_0;
9623         if (ndr_flags & NDR_SCALARS) {
9624                 NDR_CHECK(ndr_pull_align(ndr, 5));
9625                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9626                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9627                 if (_ptr_object_dn) {
9628                         NDR_PULL_ALLOC(ndr, r->object_dn);
9629                 } else {
9630                         r->object_dn = NULL;
9631                 }
9632                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9633                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9634         }
9635         if (ndr_flags & NDR_BUFFERS) {
9636                 if (r->object_dn) {
9637                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9638                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9639                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9640                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9641                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9642                                 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));
9643                         }
9644                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9645                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9646                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9647                 }
9648         }
9649         return NDR_ERR_SUCCESS;
9650 }
9651
9652 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9653 {
9654         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest1");
9655         ndr->depth++;
9656         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9657         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9658         ndr->depth++;
9659         if (r->object_dn) {
9660                 ndr_print_string(ndr, "object_dn", r->object_dn);
9661         }
9662         ndr->depth--;
9663         ndr_print_GUID(ndr, "guid1", &r->guid1);
9664         ndr->depth--;
9665 }
9666
9667 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9668 {
9669         if (ndr_flags & NDR_SCALARS) {
9670                 NDR_CHECK(ndr_push_align(ndr, 5));
9671                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9672                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9673                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
9675                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string1));
9676                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string2));
9677                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
9678                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9679         }
9680         if (ndr_flags & NDR_BUFFERS) {
9681                 if (r->object_dn) {
9682                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9683                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9684                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9685                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9686                 }
9687                 if (r->string1) {
9688                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9689                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9690                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9691                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string1, ndr_charset_length(r->string1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9692                 }
9693                 if (r->string2) {
9694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9695                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9696                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9697                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string2, ndr_charset_length(r->string2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9698                 }
9699         }
9700         return NDR_ERR_SUCCESS;
9701 }
9702
9703 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
9704 {
9705         uint32_t _ptr_object_dn;
9706         TALLOC_CTX *_mem_save_object_dn_0;
9707         uint32_t _ptr_string1;
9708         TALLOC_CTX *_mem_save_string1_0;
9709         uint32_t _ptr_string2;
9710         TALLOC_CTX *_mem_save_string2_0;
9711         if (ndr_flags & NDR_SCALARS) {
9712                 NDR_CHECK(ndr_pull_align(ndr, 5));
9713                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9714                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9715                 if (_ptr_object_dn) {
9716                         NDR_PULL_ALLOC(ndr, r->object_dn);
9717                 } else {
9718                         r->object_dn = NULL;
9719                 }
9720                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
9722                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string1));
9723                 if (_ptr_string1) {
9724                         NDR_PULL_ALLOC(ndr, r->string1);
9725                 } else {
9726                         r->string1 = NULL;
9727                 }
9728                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string2));
9729                 if (_ptr_string2) {
9730                         NDR_PULL_ALLOC(ndr, r->string2);
9731                 } else {
9732                         r->string2 = NULL;
9733                 }
9734                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
9735                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9736         }
9737         if (ndr_flags & NDR_BUFFERS) {
9738                 if (r->object_dn) {
9739                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9740                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9741                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9742                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9743                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9744                                 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));
9745                         }
9746                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9747                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9749                 }
9750                 if (r->string1) {
9751                         _mem_save_string1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9752                         NDR_PULL_SET_MEM_CTX(ndr, r->string1, 0);
9753                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string1));
9754                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string1));
9755                         if (ndr_get_array_length(ndr, &r->string1) > ndr_get_array_size(ndr, &r->string1)) {
9756                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->string1), ndr_get_array_length(ndr, &r->string1));
9757                         }
9758                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t)));
9759                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string1, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t), CH_UTF16));
9760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string1_0, 0);
9761                 }
9762                 if (r->string2) {
9763                         _mem_save_string2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9764                         NDR_PULL_SET_MEM_CTX(ndr, r->string2, 0);
9765                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string2));
9766                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string2));
9767                         if (ndr_get_array_length(ndr, &r->string2) > ndr_get_array_size(ndr, &r->string2)) {
9768                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->string2), ndr_get_array_length(ndr, &r->string2));
9769                         }
9770                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t)));
9771                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string2, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t), CH_UTF16));
9772                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string2_0, 0);
9773                 }
9774         }
9775         return NDR_ERR_SUCCESS;
9776 }
9777
9778 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9779 {
9780         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest2");
9781         ndr->depth++;
9782         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9783         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9784         ndr->depth++;
9785         if (r->object_dn) {
9786                 ndr_print_string(ndr, "object_dn", r->object_dn);
9787         }
9788         ndr->depth--;
9789         ndr_print_GUID(ndr, "guid1", &r->guid1);
9790         ndr_print_uint32(ndr, "flags", r->flags);
9791         ndr_print_ptr(ndr, "string1", r->string1);
9792         ndr->depth++;
9793         if (r->string1) {
9794                 ndr_print_string(ndr, "string1", r->string1);
9795         }
9796         ndr->depth--;
9797         ndr_print_ptr(ndr, "string2", r->string2);
9798         ndr->depth++;
9799         if (r->string2) {
9800                 ndr_print_string(ndr, "string2", r->string2);
9801         }
9802         ndr->depth--;
9803         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
9804         ndr->depth--;
9805 }
9806
9807 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaGetInfoRequest *r)
9808 {
9809         if (ndr_flags & NDR_SCALARS) {
9810                 int level = ndr_push_get_switch_value(ndr, r);
9811                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
9812                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9813                 switch (level) {
9814                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9815                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9816                         break; }
9817
9818                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9819                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9820                         break; }
9821
9822                         default:
9823                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9824                 }
9825         }
9826         if (ndr_flags & NDR_BUFFERS) {
9827                 int level = ndr_push_get_switch_value(ndr, r);
9828                 switch (level) {
9829                         case DRSUAPI_DS_REPLICA_GET_INFO:
9830                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9831                         break;
9832
9833                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9834                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9835                         break;
9836
9837                         default:
9838                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9839                 }
9840         }
9841         return NDR_ERR_SUCCESS;
9842 }
9843
9844 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaGetInfoRequest *r)
9845 {
9846         int level;
9847         uint32_t _level;
9848         level = ndr_pull_get_switch_value(ndr, r);
9849         if (ndr_flags & NDR_SCALARS) {
9850                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9851                 if (_level != level) {
9852                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9853                 }
9854                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9855                 switch (level) {
9856                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9857                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9858                         break; }
9859
9860                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9861                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9862                         break; }
9863
9864                         default:
9865                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9866                 }
9867         }
9868         if (ndr_flags & NDR_BUFFERS) {
9869                 switch (level) {
9870                         case DRSUAPI_DS_REPLICA_GET_INFO:
9871                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9872                         break;
9873
9874                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9875                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9876                         break;
9877
9878                         default:
9879                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9880                 }
9881         }
9882         return NDR_ERR_SUCCESS;
9883 }
9884
9885 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaGetInfoRequest *r)
9886 {
9887         int level;
9888         level = ndr_print_get_switch_value(ndr, r);
9889         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaGetInfoRequest");
9890         switch (level) {
9891                 case DRSUAPI_DS_REPLICA_GET_INFO:
9892                         ndr_print_drsuapi_DsReplicaGetInfoRequest1(ndr, "req1", &r->req1);
9893                 break;
9894
9895                 case DRSUAPI_DS_REPLICA_GET_INFO2:
9896                         ndr_print_drsuapi_DsReplicaGetInfoRequest2(ndr, "req2", &r->req2);
9897                 break;
9898
9899                 default:
9900                         ndr_print_bad_level(ndr, name, level);
9901         }
9902 }
9903
9904 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbour *r)
9905 {
9906         if (ndr_flags & NDR_SCALARS) {
9907                 NDR_CHECK(ndr_push_align(ndr, 8));
9908                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context_dn));
9909                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
9910                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
9911                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_obj_dn));
9912                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
9913                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9914                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9915                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9916                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9917                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9918                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
9919                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
9920                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_success));
9921                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
9922                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
9923                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
9924                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9925         }
9926         if (ndr_flags & NDR_BUFFERS) {
9927                 if (r->naming_context_dn) {
9928                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9929                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9930                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9931                         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));
9932                 }
9933                 if (r->source_dsa_obj_dn) {
9934                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9935                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9936                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9937                         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));
9938                 }
9939                 if (r->source_dsa_address) {
9940                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9941                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9942                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9943                         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));
9944                 }
9945                 if (r->transport_obj_dn) {
9946                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9947                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9948                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9949                         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));
9950                 }
9951         }
9952         return NDR_ERR_SUCCESS;
9953 }
9954
9955 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
9956 {
9957         uint32_t _ptr_naming_context_dn;
9958         TALLOC_CTX *_mem_save_naming_context_dn_0;
9959         uint32_t _ptr_source_dsa_obj_dn;
9960         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
9961         uint32_t _ptr_source_dsa_address;
9962         TALLOC_CTX *_mem_save_source_dsa_address_0;
9963         uint32_t _ptr_transport_obj_dn;
9964         TALLOC_CTX *_mem_save_transport_obj_dn_0;
9965         if (ndr_flags & NDR_SCALARS) {
9966                 NDR_CHECK(ndr_pull_align(ndr, 8));
9967                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context_dn));
9968                 if (_ptr_naming_context_dn) {
9969                         NDR_PULL_ALLOC(ndr, r->naming_context_dn);
9970                 } else {
9971                         r->naming_context_dn = NULL;
9972                 }
9973                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
9974                 if (_ptr_source_dsa_obj_dn) {
9975                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
9976                 } else {
9977                         r->source_dsa_obj_dn = NULL;
9978                 }
9979                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
9980                 if (_ptr_source_dsa_address) {
9981                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
9982                 } else {
9983                         r->source_dsa_address = NULL;
9984                 }
9985                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_obj_dn));
9986                 if (_ptr_transport_obj_dn) {
9987                         NDR_PULL_ALLOC(ndr, r->transport_obj_dn);
9988                 } else {
9989                         r->transport_obj_dn = NULL;
9990                 }
9991                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
9992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9993                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9994                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9995                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9996                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9997                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
9998                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
9999                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_success));
10000                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
10001                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
10002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
10003                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10004         }
10005         if (ndr_flags & NDR_BUFFERS) {
10006                 if (r->naming_context_dn) {
10007                         _mem_save_naming_context_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10008                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
10009                         NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
10010                         NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
10011                         if (ndr_get_array_length(ndr, &r->naming_context_dn) > ndr_get_array_size(ndr, &r->naming_context_dn)) {
10012                                 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));
10013                         }
10014                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t)));
10015                         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));
10016                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
10017                 }
10018                 if (r->source_dsa_obj_dn) {
10019                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10020                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
10021                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
10022                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
10023                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
10024                                 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));
10025                         }
10026                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
10027                         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));
10028                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
10029                 }
10030                 if (r->source_dsa_address) {
10031                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10032                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
10033                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
10034                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
10035                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
10036                                 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));
10037                         }
10038                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
10039                         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));
10040                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
10041                 }
10042                 if (r->transport_obj_dn) {
10043                         _mem_save_transport_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10044                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
10045                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
10046                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
10047                         if (ndr_get_array_length(ndr, &r->transport_obj_dn) > ndr_get_array_size(ndr, &r->transport_obj_dn)) {
10048                                 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));
10049                         }
10050                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t)));
10051                         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));
10052                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
10053                 }
10054         }
10055         return NDR_ERR_SUCCESS;
10056 }
10057
10058 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbour(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbour *r)
10059 {
10060         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbour");
10061         ndr->depth++;
10062         ndr_print_ptr(ndr, "naming_context_dn", r->naming_context_dn);
10063         ndr->depth++;
10064         if (r->naming_context_dn) {
10065                 ndr_print_string(ndr, "naming_context_dn", r->naming_context_dn);
10066         }
10067         ndr->depth--;
10068         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10069         ndr->depth++;
10070         if (r->source_dsa_obj_dn) {
10071                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10072         }
10073         ndr->depth--;
10074         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
10075         ndr->depth++;
10076         if (r->source_dsa_address) {
10077                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
10078         }
10079         ndr->depth--;
10080         ndr_print_ptr(ndr, "transport_obj_dn", r->transport_obj_dn);
10081         ndr->depth++;
10082         if (r->transport_obj_dn) {
10083                 ndr_print_string(ndr, "transport_obj_dn", r->transport_obj_dn);
10084         }
10085         ndr->depth--;
10086         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
10087         ndr_print_uint32(ndr, "reserved", r->reserved);
10088         ndr_print_GUID(ndr, "naming_context_obj_guid", &r->naming_context_obj_guid);
10089         ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
10090         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
10091         ndr_print_GUID(ndr, "transport_obj_guid", &r->transport_obj_guid);
10092         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
10093         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
10094         ndr_print_NTTIME(ndr, "last_success", r->last_success);
10095         ndr_print_NTTIME(ndr, "last_attempt", r->last_attempt);
10096         ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
10097         ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
10098         ndr->depth--;
10099 }
10100
10101 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbourCtr *r)
10102 {
10103         uint32_t cntr_array_0;
10104         if (ndr_flags & NDR_SCALARS) {
10105                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10106                 NDR_CHECK(ndr_push_align(ndr, 8));
10107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10109                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10110                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10111                 }
10112                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10113         }
10114         if (ndr_flags & NDR_BUFFERS) {
10115                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10116                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10117                 }
10118         }
10119         return NDR_ERR_SUCCESS;
10120 }
10121
10122 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
10123 {
10124         uint32_t cntr_array_0;
10125         TALLOC_CTX *_mem_save_array_0;
10126         if (ndr_flags & NDR_SCALARS) {
10127                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10128                 NDR_CHECK(ndr_pull_align(ndr, 8));
10129                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10131                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10132                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10133                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10134                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10135                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10136                 }
10137                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10138                 if (r->array) {
10139                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10140                 }
10141                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10142         }
10143         if (ndr_flags & NDR_BUFFERS) {
10144                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10145                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10146                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10147                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10148                 }
10149                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10150         }
10151         return NDR_ERR_SUCCESS;
10152 }
10153
10154 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbourCtr *r)
10155 {
10156         uint32_t cntr_array_0;
10157         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbourCtr");
10158         ndr->depth++;
10159         ndr_print_uint32(ndr, "count", r->count);
10160         ndr_print_uint32(ndr, "reserved", r->reserved);
10161         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10162         ndr->depth++;
10163         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10164                 char *idx_0=NULL;
10165                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10166                         ndr_print_drsuapi_DsReplicaNeighbour(ndr, "array", &r->array[cntr_array_0]);
10167                         free(idx_0);
10168                 }
10169         }
10170         ndr->depth--;
10171         ndr->depth--;
10172 }
10173
10174 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtr *r)
10175 {
10176         uint32_t cntr_array_0;
10177         if (ndr_flags & NDR_SCALARS) {
10178                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10179                 NDR_CHECK(ndr_push_align(ndr, 8));
10180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10182                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10183                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10184                 }
10185                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10186         }
10187         if (ndr_flags & NDR_BUFFERS) {
10188         }
10189         return NDR_ERR_SUCCESS;
10190 }
10191
10192 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
10193 {
10194         uint32_t cntr_array_0;
10195         TALLOC_CTX *_mem_save_array_0;
10196         if (ndr_flags & NDR_SCALARS) {
10197                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10198                 NDR_CHECK(ndr_pull_align(ndr, 8));
10199                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10200                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10201                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10202                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10203                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10204                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10205                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10206                 }
10207                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10208                 if (r->array) {
10209                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10210                 }
10211                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10212         }
10213         if (ndr_flags & NDR_BUFFERS) {
10214         }
10215         return NDR_ERR_SUCCESS;
10216 }
10217
10218 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtr *r)
10219 {
10220         uint32_t cntr_array_0;
10221         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtr");
10222         ndr->depth++;
10223         ndr_print_uint32(ndr, "count", r->count);
10224         ndr_print_uint32(ndr, "reserved", r->reserved);
10225         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10226         ndr->depth++;
10227         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10228                 char *idx_0=NULL;
10229                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10230                         ndr_print_drsuapi_DsReplicaCursor(ndr, "array", &r->array[cntr_array_0]);
10231                         free(idx_0);
10232                 }
10233         }
10234         ndr->depth--;
10235         ndr->depth--;
10236 }
10237
10238 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData *r)
10239 {
10240         if (ndr_flags & NDR_SCALARS) {
10241                 NDR_CHECK(ndr_push_align(ndr, 8));
10242                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10244                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10245                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10246                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10247                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10248                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10249         }
10250         if (ndr_flags & NDR_BUFFERS) {
10251                 if (r->attribute_name) {
10252                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10253                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10254                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10255                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10256                 }
10257         }
10258         return NDR_ERR_SUCCESS;
10259 }
10260
10261 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
10262 {
10263         uint32_t _ptr_attribute_name;
10264         TALLOC_CTX *_mem_save_attribute_name_0;
10265         if (ndr_flags & NDR_SCALARS) {
10266                 NDR_CHECK(ndr_pull_align(ndr, 8));
10267                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10268                 if (_ptr_attribute_name) {
10269                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10270                 } else {
10271                         r->attribute_name = NULL;
10272                 }
10273                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10274                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10275                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10276                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10277                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10278                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10279         }
10280         if (ndr_flags & NDR_BUFFERS) {
10281                 if (r->attribute_name) {
10282                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10283                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10284                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10285                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10286                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10287                                 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));
10288                         }
10289                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10290                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10291                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10292                 }
10293         }
10294         return NDR_ERR_SUCCESS;
10295 }
10296
10297 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData *r)
10298 {
10299         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData");
10300         ndr->depth++;
10301         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10302         ndr->depth++;
10303         if (r->attribute_name) {
10304                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10305         }
10306         ndr->depth--;
10307         ndr_print_uint32(ndr, "version", r->version);
10308         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10309         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10310         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10311         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10312         ndr->depth--;
10313 }
10314
10315 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10316 {
10317         uint32_t cntr_array_0;
10318         if (ndr_flags & NDR_SCALARS) {
10319                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10320                 NDR_CHECK(ndr_push_align(ndr, 8));
10321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10322                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10323                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10324                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10325                 }
10326                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10327         }
10328         if (ndr_flags & NDR_BUFFERS) {
10329                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10330                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10331                 }
10332         }
10333         return NDR_ERR_SUCCESS;
10334 }
10335
10336 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
10337 {
10338         uint32_t cntr_array_0;
10339         TALLOC_CTX *_mem_save_array_0;
10340         if (ndr_flags & NDR_SCALARS) {
10341                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10342                 NDR_CHECK(ndr_pull_align(ndr, 8));
10343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10345                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10346                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10347                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10348                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10349                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10350                 }
10351                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10352                 if (r->array) {
10353                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10354                 }
10355                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10356         }
10357         if (ndr_flags & NDR_BUFFERS) {
10358                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10359                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10360                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10361                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10362                 }
10363                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10364         }
10365         return NDR_ERR_SUCCESS;
10366 }
10367
10368 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10369 {
10370         uint32_t cntr_array_0;
10371         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaDataCtr");
10372         ndr->depth++;
10373         ndr_print_uint32(ndr, "count", r->count);
10374         ndr_print_uint32(ndr, "reserved", r->reserved);
10375         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10376         ndr->depth++;
10377         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10378                 char *idx_0=NULL;
10379                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10380                         ndr_print_drsuapi_DsReplicaObjMetaData(ndr, "array", &r->array[cntr_array_0]);
10381                         free(idx_0);
10382                 }
10383         }
10384         ndr->depth--;
10385         ndr->depth--;
10386 }
10387
10388 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
10389 {
10390         if (ndr_flags & NDR_SCALARS) {
10391                 NDR_CHECK(ndr_push_align(ndr, 5));
10392                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
10393                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10394                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
10395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
10396                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
10397                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10398         }
10399         if (ndr_flags & NDR_BUFFERS) {
10400                 if (r->dsa_obj_dn) {
10401                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10402                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10403                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10404                         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));
10405                 }
10406         }
10407         return NDR_ERR_SUCCESS;
10408 }
10409
10410 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
10411 {
10412         uint32_t _ptr_dsa_obj_dn;
10413         TALLOC_CTX *_mem_save_dsa_obj_dn_0;
10414         if (ndr_flags & NDR_SCALARS) {
10415                 NDR_CHECK(ndr_pull_align(ndr, 5));
10416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
10417                 if (_ptr_dsa_obj_dn) {
10418                         NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
10419                 } else {
10420                         r->dsa_obj_dn = NULL;
10421                 }
10422                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10423                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
10424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
10425                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
10426                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10427         }
10428         if (ndr_flags & NDR_BUFFERS) {
10429                 if (r->dsa_obj_dn) {
10430                         _mem_save_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10431                         NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
10432                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
10433                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
10434                         if (ndr_get_array_length(ndr, &r->dsa_obj_dn) > ndr_get_array_size(ndr, &r->dsa_obj_dn)) {
10435                                 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));
10436                         }
10437                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t)));
10438                         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));
10439                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
10440                 }
10441         }
10442         return NDR_ERR_SUCCESS;
10443 }
10444
10445 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailure(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailure *r)
10446 {
10447         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailure");
10448         ndr->depth++;
10449         ndr_print_ptr(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10450         ndr->depth++;
10451         if (r->dsa_obj_dn) {
10452                 ndr_print_string(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10453         }
10454         ndr->depth--;
10455         ndr_print_GUID(ndr, "dsa_obj_guid", &r->dsa_obj_guid);
10456         ndr_print_NTTIME(ndr, "first_failure", r->first_failure);
10457         ndr_print_uint32(ndr, "num_failures", r->num_failures);
10458         ndr_print_WERROR(ndr, "last_result", r->last_result);
10459         ndr->depth--;
10460 }
10461
10462 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10463 {
10464         uint32_t cntr_array_0;
10465         if (ndr_flags & NDR_SCALARS) {
10466                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10467                 NDR_CHECK(ndr_push_align(ndr, 5));
10468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10470                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10471                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10472                 }
10473                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10474         }
10475         if (ndr_flags & NDR_BUFFERS) {
10476                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10477                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10478                 }
10479         }
10480         return NDR_ERR_SUCCESS;
10481 }
10482
10483 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10484 {
10485         uint32_t cntr_array_0;
10486         TALLOC_CTX *_mem_save_array_0;
10487         if (ndr_flags & NDR_SCALARS) {
10488                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10489                 NDR_CHECK(ndr_pull_align(ndr, 5));
10490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10492                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10493                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10494                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10495                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10496                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10497                 }
10498                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10499                 if (r->array) {
10500                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10501                 }
10502                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10503         }
10504         if (ndr_flags & NDR_BUFFERS) {
10505                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10506                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10507                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10508                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10509                 }
10510                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10511         }
10512         return NDR_ERR_SUCCESS;
10513 }
10514
10515 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10516 {
10517         uint32_t cntr_array_0;
10518         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailuresCtr");
10519         ndr->depth++;
10520         ndr_print_uint32(ndr, "count", r->count);
10521         ndr_print_uint32(ndr, "reserved", r->reserved);
10522         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10523         ndr->depth++;
10524         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10525                 char *idx_0=NULL;
10526                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10527                         ndr_print_drsuapi_DsReplicaKccDsaFailure(ndr, "array", &r->array[cntr_array_0]);
10528                         free(idx_0);
10529                 }
10530         }
10531         ndr->depth--;
10532         ndr->depth--;
10533 }
10534
10535 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
10536 {
10537         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
10538         return NDR_ERR_SUCCESS;
10539 }
10540
10541 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
10542 {
10543         uint16_t v;
10544         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
10545         *r = v;
10546         return NDR_ERR_SUCCESS;
10547 }
10548
10549 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaOpType r)
10550 {
10551         const char *val = NULL;
10552
10553         switch (r) {
10554                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: val = "DRSUAPI_DS_REPLICA_OP_TYPE_SYNC"; break;
10555                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: val = "DRSUAPI_DS_REPLICA_OP_TYPE_ADD"; break;
10556                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: val = "DRSUAPI_DS_REPLICA_OP_TYPE_DELETE"; break;
10557                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: val = "DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY"; break;
10558                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: val = "DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS"; break;
10559         }
10560         ndr_print_enum(ndr, name, "ENUM", val, r);
10561 }
10562
10563 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
10564 {
10565         if (ndr_flags & NDR_SCALARS) {
10566                 NDR_CHECK(ndr_push_align(ndr, 5));
10567                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
10568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
10569                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
10570                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
10571                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
10572                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
10573                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
10574                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
10575                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10576                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10577                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10578         }
10579         if (ndr_flags & NDR_BUFFERS) {
10580                 if (r->nc_dn) {
10581                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10582                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10583                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10584                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10585                 }
10586                 if (r->remote_dsa_obj_dn) {
10587                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10588                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10589                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10590                         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));
10591                 }
10592                 if (r->remote_dsa_address) {
10593                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10594                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10595                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10596                         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));
10597                 }
10598         }
10599         return NDR_ERR_SUCCESS;
10600 }
10601
10602 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
10603 {
10604         uint32_t _ptr_nc_dn;
10605         TALLOC_CTX *_mem_save_nc_dn_0;
10606         uint32_t _ptr_remote_dsa_obj_dn;
10607         TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
10608         uint32_t _ptr_remote_dsa_address;
10609         TALLOC_CTX *_mem_save_remote_dsa_address_0;
10610         if (ndr_flags & NDR_SCALARS) {
10611                 NDR_CHECK(ndr_pull_align(ndr, 5));
10612                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
10613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
10614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
10615                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
10616                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
10617                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
10618                 if (_ptr_nc_dn) {
10619                         NDR_PULL_ALLOC(ndr, r->nc_dn);
10620                 } else {
10621                         r->nc_dn = NULL;
10622                 }
10623                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_obj_dn));
10624                 if (_ptr_remote_dsa_obj_dn) {
10625                         NDR_PULL_ALLOC(ndr, r->remote_dsa_obj_dn);
10626                 } else {
10627                         r->remote_dsa_obj_dn = NULL;
10628                 }
10629                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_address));
10630                 if (_ptr_remote_dsa_address) {
10631                         NDR_PULL_ALLOC(ndr, r->remote_dsa_address);
10632                 } else {
10633                         r->remote_dsa_address = NULL;
10634                 }
10635                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10636                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10637                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10638         }
10639         if (ndr_flags & NDR_BUFFERS) {
10640                 if (r->nc_dn) {
10641                         _mem_save_nc_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10642                         NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
10643                         NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
10644                         NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
10645                         if (ndr_get_array_length(ndr, &r->nc_dn) > ndr_get_array_size(ndr, &r->nc_dn)) {
10646                                 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));
10647                         }
10648                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t)));
10649                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t), CH_UTF16));
10650                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
10651                 }
10652                 if (r->remote_dsa_obj_dn) {
10653                         _mem_save_remote_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10654                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
10655                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
10656                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
10657                         if (ndr_get_array_length(ndr, &r->remote_dsa_obj_dn) > ndr_get_array_size(ndr, &r->remote_dsa_obj_dn)) {
10658                                 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));
10659                         }
10660                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t)));
10661                         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));
10662                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
10663                 }
10664                 if (r->remote_dsa_address) {
10665                         _mem_save_remote_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10666                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
10667                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
10668                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
10669                         if (ndr_get_array_length(ndr, &r->remote_dsa_address) > ndr_get_array_size(ndr, &r->remote_dsa_address)) {
10670                                 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));
10671                         }
10672                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t)));
10673                         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));
10674                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
10675                 }
10676         }
10677         return NDR_ERR_SUCCESS;
10678 }
10679
10680 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOp *r)
10681 {
10682         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOp");
10683         ndr->depth++;
10684         ndr_print_NTTIME(ndr, "operation_start", r->operation_start);
10685         ndr_print_uint32(ndr, "serial_num", r->serial_num);
10686         ndr_print_uint32(ndr, "priority", r->priority);
10687         ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
10688         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
10689         ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
10690         ndr->depth++;
10691         if (r->nc_dn) {
10692                 ndr_print_string(ndr, "nc_dn", r->nc_dn);
10693         }
10694         ndr->depth--;
10695         ndr_print_ptr(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10696         ndr->depth++;
10697         if (r->remote_dsa_obj_dn) {
10698                 ndr_print_string(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10699         }
10700         ndr->depth--;
10701         ndr_print_ptr(ndr, "remote_dsa_address", r->remote_dsa_address);
10702         ndr->depth++;
10703         if (r->remote_dsa_address) {
10704                 ndr_print_string(ndr, "remote_dsa_address", r->remote_dsa_address);
10705         }
10706         ndr->depth--;
10707         ndr_print_GUID(ndr, "nc_obj_guid", &r->nc_obj_guid);
10708         ndr_print_GUID(ndr, "remote_dsa_obj_guid", &r->remote_dsa_obj_guid);
10709         ndr->depth--;
10710 }
10711
10712 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOpCtr *r)
10713 {
10714         uint32_t cntr_array_0;
10715         if (ndr_flags & NDR_SCALARS) {
10716                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10717                 NDR_CHECK(ndr_push_align(ndr, 5));
10718                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
10719                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10720                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10721                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10722                 }
10723                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10724         }
10725         if (ndr_flags & NDR_BUFFERS) {
10726                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10727                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10728                 }
10729         }
10730         return NDR_ERR_SUCCESS;
10731 }
10732
10733 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
10734 {
10735         uint32_t cntr_array_0;
10736         TALLOC_CTX *_mem_save_array_0;
10737         if (ndr_flags & NDR_SCALARS) {
10738                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10739                 NDR_CHECK(ndr_pull_align(ndr, 5));
10740                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
10741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10742                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10743                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10744                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10745                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10746                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10747                 }
10748                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10749                 if (r->array) {
10750                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10751                 }
10752                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10753         }
10754         if (ndr_flags & NDR_BUFFERS) {
10755                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10756                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10757                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10758                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10759                 }
10760                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10761         }
10762         return NDR_ERR_SUCCESS;
10763 }
10764
10765 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOpCtr *r)
10766 {
10767         uint32_t cntr_array_0;
10768         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOpCtr");
10769         ndr->depth++;
10770         ndr_print_NTTIME(ndr, "time", r->time);
10771         ndr_print_uint32(ndr, "count", r->count);
10772         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10773         ndr->depth++;
10774         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10775                 char *idx_0=NULL;
10776                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10777                         ndr_print_drsuapi_DsReplicaOp(ndr, "array", &r->array[cntr_array_0]);
10778                         free(idx_0);
10779                 }
10780         }
10781         ndr->depth--;
10782         ndr->depth--;
10783 }
10784
10785 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData *r)
10786 {
10787         if (ndr_flags & NDR_SCALARS) {
10788                 NDR_CHECK(ndr_push_align(ndr, 8));
10789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10790                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
10791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
10792                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
10793                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
10794                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
10795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10796                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10797                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10798                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10799                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10800                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10801         }
10802         if (ndr_flags & NDR_BUFFERS) {
10803                 if (r->attribute_name) {
10804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10805                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10806                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10807                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10808                 }
10809                 if (r->object_dn) {
10810                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10811                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10812                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10813                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10814                 }
10815                 if (r->binary) {
10816                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
10817                 }
10818         }
10819         return NDR_ERR_SUCCESS;
10820 }
10821
10822 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
10823 {
10824         uint32_t _ptr_attribute_name;
10825         TALLOC_CTX *_mem_save_attribute_name_0;
10826         uint32_t _ptr_object_dn;
10827         TALLOC_CTX *_mem_save_object_dn_0;
10828         uint32_t _ptr_binary;
10829         TALLOC_CTX *_mem_save_binary_0;
10830         if (ndr_flags & NDR_SCALARS) {
10831                 NDR_CHECK(ndr_pull_align(ndr, 8));
10832                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10833                 if (_ptr_attribute_name) {
10834                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10835                 } else {
10836                         r->attribute_name = NULL;
10837                 }
10838                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
10839                 if (_ptr_object_dn) {
10840                         NDR_PULL_ALLOC(ndr, r->object_dn);
10841                 } else {
10842                         r->object_dn = NULL;
10843                 }
10844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
10845                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
10846                 if (_ptr_binary) {
10847                         NDR_PULL_ALLOC(ndr, r->binary);
10848                 } else {
10849                         r->binary = NULL;
10850                 }
10851                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
10852                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
10853                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10854                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10855                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10856                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10857                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10858                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10859         }
10860         if (ndr_flags & NDR_BUFFERS) {
10861                 if (r->attribute_name) {
10862                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10863                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10864                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10865                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10866                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10867                                 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));
10868                         }
10869                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10870                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10871                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10872                 }
10873                 if (r->object_dn) {
10874                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10875                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
10876                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
10877                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
10878                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
10879                                 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));
10880                         }
10881                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
10882                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
10883                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
10884                 }
10885                 if (r->binary) {
10886                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
10887                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
10888                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
10889                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
10890                 }
10891         }
10892         return NDR_ERR_SUCCESS;
10893 }
10894
10895 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData *r)
10896 {
10897         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData");
10898         ndr->depth++;
10899         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10900         ndr->depth++;
10901         if (r->attribute_name) {
10902                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10903         }
10904         ndr->depth--;
10905         ndr_print_ptr(ndr, "object_dn", r->object_dn);
10906         ndr->depth++;
10907         if (r->object_dn) {
10908                 ndr_print_string(ndr, "object_dn", r->object_dn);
10909         }
10910         ndr->depth--;
10911         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);
10912         ndr_print_ptr(ndr, "binary", r->binary);
10913         ndr->depth++;
10914         if (r->binary) {
10915                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
10916         }
10917         ndr->depth--;
10918         ndr_print_NTTIME(ndr, "deleted", r->deleted);
10919         ndr_print_NTTIME(ndr, "created", r->created);
10920         ndr_print_uint32(ndr, "version", r->version);
10921         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10922         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10923         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10924         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10925         ndr->depth--;
10926 }
10927
10928 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10929 {
10930         uint32_t cntr_array_0;
10931         if (ndr_flags & NDR_SCALARS) {
10932                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10933                 NDR_CHECK(ndr_push_align(ndr, 8));
10934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10935                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
10936                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10937                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10938                 }
10939                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10940         }
10941         if (ndr_flags & NDR_BUFFERS) {
10942                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10943                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10944                 }
10945         }
10946         return NDR_ERR_SUCCESS;
10947 }
10948
10949 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10950 {
10951         uint32_t cntr_array_0;
10952         TALLOC_CTX *_mem_save_array_0;
10953         if (ndr_flags & NDR_SCALARS) {
10954                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10955                 NDR_CHECK(ndr_pull_align(ndr, 8));
10956                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10957                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
10958                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10959                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10960                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10961                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10962                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10963                 }
10964                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10965                 if (r->array) {
10966                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10967                 }
10968                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10969         }
10970         if (ndr_flags & NDR_BUFFERS) {
10971                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10972                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10973                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10974                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10975                 }
10976                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10977         }
10978         return NDR_ERR_SUCCESS;
10979 }
10980
10981 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10982 {
10983         uint32_t cntr_array_0;
10984         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaDataCtr");
10985         ndr->depth++;
10986         ndr_print_uint32(ndr, "count", r->count);
10987         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
10988         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10989         ndr->depth++;
10990         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10991                 char *idx_0=NULL;
10992                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10993                         ndr_print_drsuapi_DsReplicaAttrValMetaData(ndr, "array", &r->array[cntr_array_0]);
10994                         free(idx_0);
10995                 }
10996         }
10997         ndr->depth--;
10998         ndr->depth--;
10999 }
11000
11001 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2Ctr *r)
11002 {
11003         uint32_t cntr_array_0;
11004         if (ndr_flags & NDR_SCALARS) {
11005                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11006                 NDR_CHECK(ndr_push_align(ndr, 8));
11007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11008                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11009                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11010                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11011                 }
11012                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11013         }
11014         if (ndr_flags & NDR_BUFFERS) {
11015         }
11016         return NDR_ERR_SUCCESS;
11017 }
11018
11019 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
11020 {
11021         uint32_t cntr_array_0;
11022         TALLOC_CTX *_mem_save_array_0;
11023         if (ndr_flags & NDR_SCALARS) {
11024                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11025                 NDR_CHECK(ndr_pull_align(ndr, 8));
11026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11028                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11029                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11030                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11031                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11032                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11033                 }
11034                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11035                 if (r->array) {
11036                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11037                 }
11038                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11039         }
11040         if (ndr_flags & NDR_BUFFERS) {
11041         }
11042         return NDR_ERR_SUCCESS;
11043 }
11044
11045 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2Ctr *r)
11046 {
11047         uint32_t cntr_array_0;
11048         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2Ctr");
11049         ndr->depth++;
11050         ndr_print_uint32(ndr, "count", r->count);
11051         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11052         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11053         ndr->depth++;
11054         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11055                 char *idx_0=NULL;
11056                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11057                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "array", &r->array[cntr_array_0]);
11058                         free(idx_0);
11059                 }
11060         }
11061         ndr->depth--;
11062         ndr->depth--;
11063 }
11064
11065 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3 *r)
11066 {
11067         if (ndr_flags & NDR_SCALARS) {
11068                 NDR_CHECK(ndr_push_align(ndr, 8));
11069                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11070                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
11071                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
11072                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
11073                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11074         }
11075         if (ndr_flags & NDR_BUFFERS) {
11076                 if (r->source_dsa_obj_dn) {
11077                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11078                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11079                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11080                         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));
11081                 }
11082         }
11083         return NDR_ERR_SUCCESS;
11084 }
11085
11086 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
11087 {
11088         uint32_t _ptr_source_dsa_obj_dn;
11089         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
11090         if (ndr_flags & NDR_SCALARS) {
11091                 NDR_CHECK(ndr_pull_align(ndr, 8));
11092                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11093                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
11094                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
11095                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
11096                 if (_ptr_source_dsa_obj_dn) {
11097                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
11098                 } else {
11099                         r->source_dsa_obj_dn = NULL;
11100                 }
11101                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11102         }
11103         if (ndr_flags & NDR_BUFFERS) {
11104                 if (r->source_dsa_obj_dn) {
11105                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11106                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
11107                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
11108                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
11109                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
11110                                 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));
11111                         }
11112                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
11113                         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));
11114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
11115                 }
11116         }
11117         return NDR_ERR_SUCCESS;
11118 }
11119
11120 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3 *r)
11121 {
11122         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3");
11123         ndr->depth++;
11124         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
11125         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
11126         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
11127         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11128         ndr->depth++;
11129         if (r->source_dsa_obj_dn) {
11130                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11131         }
11132         ndr->depth--;
11133         ndr->depth--;
11134 }
11135
11136 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3Ctr *r)
11137 {
11138         uint32_t cntr_array_0;
11139         if (ndr_flags & NDR_SCALARS) {
11140                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11141                 NDR_CHECK(ndr_push_align(ndr, 8));
11142                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11143                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11144                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11145                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11146                 }
11147                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11148         }
11149         if (ndr_flags & NDR_BUFFERS) {
11150                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11151                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11152                 }
11153         }
11154         return NDR_ERR_SUCCESS;
11155 }
11156
11157 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
11158 {
11159         uint32_t cntr_array_0;
11160         TALLOC_CTX *_mem_save_array_0;
11161         if (ndr_flags & NDR_SCALARS) {
11162                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11163                 NDR_CHECK(ndr_pull_align(ndr, 8));
11164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11166                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11167                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11168                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11169                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11170                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11171                 }
11172                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11173                 if (r->array) {
11174                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11175                 }
11176                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11177         }
11178         if (ndr_flags & NDR_BUFFERS) {
11179                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11180                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11181                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11182                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11183                 }
11184                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11185         }
11186         return NDR_ERR_SUCCESS;
11187 }
11188
11189 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3Ctr *r)
11190 {
11191         uint32_t cntr_array_0;
11192         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3Ctr");
11193         ndr->depth++;
11194         ndr_print_uint32(ndr, "count", r->count);
11195         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11196         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11197         ndr->depth++;
11198         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11199                 char *idx_0=NULL;
11200                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11201                         ndr_print_drsuapi_DsReplicaCursor3(ndr, "array", &r->array[cntr_array_0]);
11202                         free(idx_0);
11203                 }
11204         }
11205         ndr->depth--;
11206         ndr->depth--;
11207 }
11208
11209 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2 *r)
11210 {
11211         if (ndr_flags & NDR_SCALARS) {
11212                 NDR_CHECK(ndr_push_align(ndr, 8));
11213                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11214                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11215                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11216                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11217                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11218                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11219                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11220                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11221         }
11222         if (ndr_flags & NDR_BUFFERS) {
11223                 if (r->attribute_name) {
11224                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11225                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11226                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11227                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11228                 }
11229                 if (r->originating_dsa_dn) {
11230                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11231                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11232                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11233                         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));
11234                 }
11235         }
11236         return NDR_ERR_SUCCESS;
11237 }
11238
11239 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
11240 {
11241         uint32_t _ptr_attribute_name;
11242         TALLOC_CTX *_mem_save_attribute_name_0;
11243         uint32_t _ptr_originating_dsa_dn;
11244         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11245         if (ndr_flags & NDR_SCALARS) {
11246                 NDR_CHECK(ndr_pull_align(ndr, 8));
11247                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11248                 if (_ptr_attribute_name) {
11249                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11250                 } else {
11251                         r->attribute_name = NULL;
11252                 }
11253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11254                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11255                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11256                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11257                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11258                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11259                 if (_ptr_originating_dsa_dn) {
11260                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11261                 } else {
11262                         r->originating_dsa_dn = NULL;
11263                 }
11264                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11265         }
11266         if (ndr_flags & NDR_BUFFERS) {
11267                 if (r->attribute_name) {
11268                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11269                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11270                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11271                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11272                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11273                                 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));
11274                         }
11275                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11276                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11277                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11278                 }
11279                 if (r->originating_dsa_dn) {
11280                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11281                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11282                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11283                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11284                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11285                                 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));
11286                         }
11287                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11288                         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));
11289                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11290                 }
11291         }
11292         return NDR_ERR_SUCCESS;
11293 }
11294
11295 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2 *r)
11296 {
11297         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2");
11298         ndr->depth++;
11299         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11300         ndr->depth++;
11301         if (r->attribute_name) {
11302                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11303         }
11304         ndr->depth--;
11305         ndr_print_uint32(ndr, "version", r->version);
11306         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11307         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11308         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11309         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11310         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11311         ndr->depth++;
11312         if (r->originating_dsa_dn) {
11313                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11314         }
11315         ndr->depth--;
11316         ndr->depth--;
11317 }
11318
11319 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11320 {
11321         uint32_t cntr_array_0;
11322         if (ndr_flags & NDR_SCALARS) {
11323                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11324                 NDR_CHECK(ndr_push_align(ndr, 8));
11325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11327                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11328                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11329                 }
11330                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11331         }
11332         if (ndr_flags & NDR_BUFFERS) {
11333                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11334                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11335                 }
11336         }
11337         return NDR_ERR_SUCCESS;
11338 }
11339
11340 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11341 {
11342         uint32_t cntr_array_0;
11343         TALLOC_CTX *_mem_save_array_0;
11344         if (ndr_flags & NDR_SCALARS) {
11345                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11346                 NDR_CHECK(ndr_pull_align(ndr, 8));
11347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11349                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11350                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11351                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11352                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11353                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11354                 }
11355                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11356                 if (r->array) {
11357                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11358                 }
11359                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11360         }
11361         if (ndr_flags & NDR_BUFFERS) {
11362                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11363                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11364                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11365                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11366                 }
11367                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11368         }
11369         return NDR_ERR_SUCCESS;
11370 }
11371
11372 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11373 {
11374         uint32_t cntr_array_0;
11375         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2Ctr");
11376         ndr->depth++;
11377         ndr_print_uint32(ndr, "count", r->count);
11378         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11379         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11380         ndr->depth++;
11381         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11382                 char *idx_0=NULL;
11383                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11384                         ndr_print_drsuapi_DsReplicaObjMetaData2(ndr, "array", &r->array[cntr_array_0]);
11385                         free(idx_0);
11386                 }
11387         }
11388         ndr->depth--;
11389         ndr->depth--;
11390 }
11391
11392 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11393 {
11394         if (ndr_flags & NDR_SCALARS) {
11395                 NDR_CHECK(ndr_push_align(ndr, 8));
11396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11397                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11399                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11400                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11401                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11403                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11404                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11405                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11406                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11407                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11408                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11409         }
11410         if (ndr_flags & NDR_BUFFERS) {
11411                 if (r->attribute_name) {
11412                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11413                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11414                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11415                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11416                 }
11417                 if (r->object_dn) {
11418                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11419                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11420                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11421                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11422                 }
11423                 if (r->binary) {
11424                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11425                 }
11426                 if (r->originating_dsa_dn) {
11427                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11428                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11429                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11430                         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));
11431                 }
11432         }
11433         return NDR_ERR_SUCCESS;
11434 }
11435
11436 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
11437 {
11438         uint32_t _ptr_attribute_name;
11439         TALLOC_CTX *_mem_save_attribute_name_0;
11440         uint32_t _ptr_object_dn;
11441         TALLOC_CTX *_mem_save_object_dn_0;
11442         uint32_t _ptr_binary;
11443         TALLOC_CTX *_mem_save_binary_0;
11444         uint32_t _ptr_originating_dsa_dn;
11445         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11446         if (ndr_flags & NDR_SCALARS) {
11447                 NDR_CHECK(ndr_pull_align(ndr, 8));
11448                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11449                 if (_ptr_attribute_name) {
11450                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11451                 } else {
11452                         r->attribute_name = NULL;
11453                 }
11454                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11455                 if (_ptr_object_dn) {
11456                         NDR_PULL_ALLOC(ndr, r->object_dn);
11457                 } else {
11458                         r->object_dn = NULL;
11459                 }
11460                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11461                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11462                 if (_ptr_binary) {
11463                         NDR_PULL_ALLOC(ndr, r->binary);
11464                 } else {
11465                         r->binary = NULL;
11466                 }
11467                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11468                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11469                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11470                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11471                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11472                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11473                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11474                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11475                 if (_ptr_originating_dsa_dn) {
11476                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11477                 } else {
11478                         r->originating_dsa_dn = NULL;
11479                 }
11480                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11481         }
11482         if (ndr_flags & NDR_BUFFERS) {
11483                 if (r->attribute_name) {
11484                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11485                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11486                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11487                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11488                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11489                                 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));
11490                         }
11491                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11492                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11493                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11494                 }
11495                 if (r->object_dn) {
11496                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11497                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11498                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11499                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11500                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11501                                 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));
11502                         }
11503                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11504                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11505                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11506                 }
11507                 if (r->binary) {
11508                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11509                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11510                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11511                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11512                 }
11513                 if (r->originating_dsa_dn) {
11514                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11515                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11516                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11517                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11518                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11519                                 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));
11520                         }
11521                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11522                         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));
11523                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11524                 }
11525         }
11526         return NDR_ERR_SUCCESS;
11527 }
11528
11529 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11530 {
11531         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2");
11532         ndr->depth++;
11533         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11534         ndr->depth++;
11535         if (r->attribute_name) {
11536                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11537         }
11538         ndr->depth--;
11539         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11540         ndr->depth++;
11541         if (r->object_dn) {
11542                 ndr_print_string(ndr, "object_dn", r->object_dn);
11543         }
11544         ndr->depth--;
11545         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);
11546         ndr_print_ptr(ndr, "binary", r->binary);
11547         ndr->depth++;
11548         if (r->binary) {
11549                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11550         }
11551         ndr->depth--;
11552         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11553         ndr_print_NTTIME(ndr, "created", r->created);
11554         ndr_print_uint32(ndr, "version", r->version);
11555         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11556         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11557         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11558         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11559         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11560         ndr->depth++;
11561         if (r->originating_dsa_dn) {
11562                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11563         }
11564         ndr->depth--;
11565         ndr->depth--;
11566 }
11567
11568 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11569 {
11570         uint32_t cntr_array_0;
11571         if (ndr_flags & NDR_SCALARS) {
11572                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11573                 NDR_CHECK(ndr_push_align(ndr, 8));
11574                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11576                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11577                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11578                 }
11579                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11580         }
11581         if (ndr_flags & NDR_BUFFERS) {
11582                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11583                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11584                 }
11585         }
11586         return NDR_ERR_SUCCESS;
11587 }
11588
11589 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11590 {
11591         uint32_t cntr_array_0;
11592         TALLOC_CTX *_mem_save_array_0;
11593         if (ndr_flags & NDR_SCALARS) {
11594                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11595                 NDR_CHECK(ndr_pull_align(ndr, 8));
11596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11597                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11598                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11599                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11600                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11601                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11602                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11603                 }
11604                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11605                 if (r->array) {
11606                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11607                 }
11608                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11609         }
11610         if (ndr_flags & NDR_BUFFERS) {
11611                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11612                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11613                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11614                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11615                 }
11616                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11617         }
11618         return NDR_ERR_SUCCESS;
11619 }
11620
11621 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11622 {
11623         uint32_t cntr_array_0;
11624         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2Ctr");
11625         ndr->depth++;
11626         ndr_print_uint32(ndr, "count", r->count);
11627         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11628         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11629         ndr->depth++;
11630         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11631                 char *idx_0=NULL;
11632                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11633                         ndr_print_drsuapi_DsReplicaAttrValMetaData2(ndr, "array", &r->array[cntr_array_0]);
11634                         free(idx_0);
11635                 }
11636         }
11637         ndr->depth--;
11638         ndr->depth--;
11639 }
11640
11641 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04 *r)
11642 {
11643         if (ndr_flags & NDR_SCALARS) {
11644                 NDR_CHECK(ndr_push_align(ndr, 8));
11645                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u1));
11646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11648                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11649                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->bind_time));
11650                 {
11651                         uint32_t _flags_save_ipv4address = ndr->flags;
11652                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11653                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
11654                         ndr->flags = _flags_save_ipv4address;
11655                 }
11656                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11657                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11658         }
11659         if (ndr_flags & NDR_BUFFERS) {
11660         }
11661         return NDR_ERR_SUCCESS;
11662 }
11663
11664 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04 *r)
11665 {
11666         if (ndr_flags & NDR_SCALARS) {
11667                 NDR_CHECK(ndr_pull_align(ndr, 8));
11668                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u1));
11669                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11670                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11671                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11672                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->bind_time));
11673                 {
11674                         uint32_t _flags_save_ipv4address = ndr->flags;
11675                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11676                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
11677                         ndr->flags = _flags_save_ipv4address;
11678                 }
11679                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11680                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11681         }
11682         if (ndr_flags & NDR_BUFFERS) {
11683         }
11684         return NDR_ERR_SUCCESS;
11685 }
11686
11687 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04 *r)
11688 {
11689         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04");
11690         ndr->depth++;
11691         ndr_print_hyper(ndr, "u1", r->u1);
11692         ndr_print_uint32(ndr, "u2", r->u2);
11693         ndr_print_uint32(ndr, "u3", r->u3);
11694         ndr_print_GUID(ndr, "bind_guid", &r->bind_guid);
11695         ndr_print_NTTIME_1sec(ndr, "bind_time", r->bind_time);
11696         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
11697         ndr_print_uint32(ndr, "u5", r->u5);
11698         ndr->depth--;
11699 }
11700
11701 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04Ctr *r)
11702 {
11703         uint32_t cntr_array_0;
11704         if (ndr_flags & NDR_SCALARS) {
11705                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11706                 NDR_CHECK(ndr_push_align(ndr, 8));
11707                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11709                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11710                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11711                 }
11712                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11713         }
11714         if (ndr_flags & NDR_BUFFERS) {
11715         }
11716         return NDR_ERR_SUCCESS;
11717 }
11718
11719 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
11720 {
11721         uint32_t cntr_array_0;
11722         TALLOC_CTX *_mem_save_array_0;
11723         if (ndr_flags & NDR_SCALARS) {
11724                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11725                 NDR_CHECK(ndr_pull_align(ndr, 8));
11726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11727                 if (r->count > 10000) {
11728                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11729                 }
11730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11731                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11732                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11733                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11734                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11735                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11736                 }
11737                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11738                 if (r->array) {
11739                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11740                 }
11741                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11742         }
11743         if (ndr_flags & NDR_BUFFERS) {
11744         }
11745         return NDR_ERR_SUCCESS;
11746 }
11747
11748 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04Ctr *r)
11749 {
11750         uint32_t cntr_array_0;
11751         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04Ctr");
11752         ndr->depth++;
11753         ndr_print_uint32(ndr, "count", r->count);
11754         ndr_print_uint32(ndr, "reserved", r->reserved);
11755         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11756         ndr->depth++;
11757         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11758                 char *idx_0=NULL;
11759                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11760                         ndr_print_drsuapi_DsReplicaConnection04(ndr, "array", &r->array[cntr_array_0]);
11761                         free(idx_0);
11762                 }
11763         }
11764         ndr->depth--;
11765         ndr->depth--;
11766 }
11767
11768 static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06 *r)
11769 {
11770         if (ndr_flags & NDR_SCALARS) {
11771                 NDR_CHECK(ndr_push_align(ndr, 8));
11772                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str1));
11773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u1));
11774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u4));
11777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11778                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
11779                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
11780                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11781         }
11782         if (ndr_flags & NDR_BUFFERS) {
11783                 if (r->str1) {
11784                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11785                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11786                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11787                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11788                 }
11789         }
11790         return NDR_ERR_SUCCESS;
11791 }
11792
11793 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
11794 {
11795         uint32_t _ptr_str1;
11796         TALLOC_CTX *_mem_save_str1_0;
11797         if (ndr_flags & NDR_SCALARS) {
11798                 NDR_CHECK(ndr_pull_align(ndr, 8));
11799                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str1));
11800                 if (_ptr_str1) {
11801                         NDR_PULL_ALLOC(ndr, r->str1);
11802                 } else {
11803                         r->str1 = NULL;
11804                 }
11805                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
11806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u4));
11809                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11810                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
11811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
11812                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11813         }
11814         if (ndr_flags & NDR_BUFFERS) {
11815                 if (r->str1) {
11816                         _mem_save_str1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11817                         NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
11818                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
11819                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
11820                         if (ndr_get_array_length(ndr, &r->str1) > ndr_get_array_size(ndr, &r->str1)) {
11821                                 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));
11822                         }
11823                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t)));
11824                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t), CH_UTF16));
11825                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
11826                 }
11827         }
11828         return NDR_ERR_SUCCESS;
11829 }
11830
11831 _PUBLIC_ void ndr_print_drsuapi_DsReplica06(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06 *r)
11832 {
11833         ndr_print_struct(ndr, name, "drsuapi_DsReplica06");
11834         ndr->depth++;
11835         ndr_print_ptr(ndr, "str1", r->str1);
11836         ndr->depth++;
11837         if (r->str1) {
11838                 ndr_print_string(ndr, "str1", r->str1);
11839         }
11840         ndr->depth--;
11841         ndr_print_uint32(ndr, "u1", r->u1);
11842         ndr_print_uint32(ndr, "u2", r->u2);
11843         ndr_print_uint32(ndr, "u3", r->u3);
11844         ndr_print_uint32(ndr, "u4", r->u4);
11845         ndr_print_uint32(ndr, "u5", r->u5);
11846         ndr_print_hyper(ndr, "u6", r->u6);
11847         ndr_print_uint32(ndr, "u7", r->u7);
11848         ndr->depth--;
11849 }
11850
11851 static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06Ctr *r)
11852 {
11853         uint32_t cntr_array_0;
11854         if (ndr_flags & NDR_SCALARS) {
11855                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11856                 NDR_CHECK(ndr_push_align(ndr, 8));
11857                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11858                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11859                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11860                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11861                 }
11862                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11863         }
11864         if (ndr_flags & NDR_BUFFERS) {
11865                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11866                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11867                 }
11868         }
11869         return NDR_ERR_SUCCESS;
11870 }
11871
11872 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *r)
11873 {
11874         uint32_t cntr_array_0;
11875         TALLOC_CTX *_mem_save_array_0;
11876         if (ndr_flags & NDR_SCALARS) {
11877                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11878                 NDR_CHECK(ndr_pull_align(ndr, 8));
11879                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11880                 if (r->count > 256) {
11881                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11882                 }
11883                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11884                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11885                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11886                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11887                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11888                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11889                 }
11890                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11891                 if (r->array) {
11892                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11893                 }
11894                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11895         }
11896         if (ndr_flags & NDR_BUFFERS) {
11897                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11898                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11899                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11900                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11901                 }
11902                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11903         }
11904         return NDR_ERR_SUCCESS;
11905 }
11906
11907 _PUBLIC_ void ndr_print_drsuapi_DsReplica06Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06Ctr *r)
11908 {
11909         uint32_t cntr_array_0;
11910         ndr_print_struct(ndr, name, "drsuapi_DsReplica06Ctr");
11911         ndr->depth++;
11912         ndr_print_uint32(ndr, "count", r->count);
11913         ndr_print_uint32(ndr, "reserved", r->reserved);
11914         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11915         ndr->depth++;
11916         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11917                 char *idx_0=NULL;
11918                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11919                         ndr_print_drsuapi_DsReplica06(ndr, "array", &r->array[cntr_array_0]);
11920                         free(idx_0);
11921                 }
11922         }
11923         ndr->depth--;
11924         ndr->depth--;
11925 }
11926
11927 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaInfo *r)
11928 {
11929         if (ndr_flags & NDR_SCALARS) {
11930                 int level = ndr_push_get_switch_value(ndr, r);
11931                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
11932                 NDR_CHECK(ndr_push_union_align(ndr, 5));
11933                 switch (level) {
11934                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
11935                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
11936                         break; }
11937
11938                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
11939                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors));
11940                         break; }
11941
11942                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
11943                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata));
11944                         break; }
11945
11946                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
11947                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connectfailures));
11948                         break; }
11949
11950                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
11951                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linkfailures));
11952                         break; }
11953
11954                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
11955                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pendingops));
11956                         break; }
11957
11958                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
11959                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata));
11960                         break; }
11961
11962                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
11963                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors2));
11964                         break; }
11965
11966                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
11967                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors3));
11968                         break; }
11969
11970                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
11971                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata2));
11972                         break; }
11973
11974                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
11975                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata2));
11976                         break; }
11977
11978                         case DRSUAPI_DS_REPLICA_INFO_REPSTO: {
11979                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->repsto));
11980                         break; }
11981
11982                         case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS: {
11983                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->clientctx));
11984                         break; }
11985
11986                         case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1: {
11987                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->udv1));
11988                         break; }
11989
11990                         case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS: {
11991                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->srvoutgoingcalls));
11992                         break; }
11993
11994                         default:
11995                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
11996                 }
11997         }
11998         if (ndr_flags & NDR_BUFFERS) {
11999                 int level = ndr_push_get_switch_value(ndr, r);
12000                 switch (level) {
12001                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12002                                 if (r->neighbours) {
12003                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12004                                 }
12005                         break;
12006
12007                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12008                                 if (r->cursors) {
12009                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12010                                 }
12011                         break;
12012
12013                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12014                                 if (r->objmetadata) {
12015                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12016                                 }
12017                         break;
12018
12019                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12020                                 if (r->connectfailures) {
12021                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12022                                 }
12023                         break;
12024
12025                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12026                                 if (r->linkfailures) {
12027                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12028                                 }
12029                         break;
12030
12031                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12032                                 if (r->pendingops) {
12033                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12034                                 }
12035                         break;
12036
12037                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12038                                 if (r->attrvalmetadata) {
12039                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12040                                 }
12041                         break;
12042
12043                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12044                                 if (r->cursors2) {
12045                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12046                                 }
12047                         break;
12048
12049                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12050                                 if (r->cursors3) {
12051                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12052                                 }
12053                         break;
12054
12055                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12056                                 if (r->objmetadata2) {
12057                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12058                                 }
12059                         break;
12060
12061                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12062                                 if (r->attrvalmetadata2) {
12063                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12064                                 }
12065                         break;
12066
12067                         case DRSUAPI_DS_REPLICA_INFO_REPSTO:
12068                                 if (r->repsto) {
12069                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->repsto));
12070                                 }
12071                         break;
12072
12073                         case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS:
12074                                 if (r->clientctx) {
12075                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->clientctx));
12076                                 }
12077                         break;
12078
12079                         case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1:
12080                                 if (r->udv1) {
12081                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->udv1));
12082                                 }
12083                         break;
12084
12085                         case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS:
12086                                 if (r->srvoutgoingcalls) {
12087                                         NDR_CHECK(ndr_push_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->srvoutgoingcalls));
12088                                 }
12089                         break;
12090
12091                         default:
12092                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12093                 }
12094         }
12095         return NDR_ERR_SUCCESS;
12096 }
12097
12098 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaInfo *r)
12099 {
12100         int level;
12101         uint32_t _level;
12102         TALLOC_CTX *_mem_save_neighbours_0;
12103         TALLOC_CTX *_mem_save_cursors_0;
12104         TALLOC_CTX *_mem_save_objmetadata_0;
12105         TALLOC_CTX *_mem_save_connectfailures_0;
12106         TALLOC_CTX *_mem_save_linkfailures_0;
12107         TALLOC_CTX *_mem_save_pendingops_0;
12108         TALLOC_CTX *_mem_save_attrvalmetadata_0;
12109         TALLOC_CTX *_mem_save_cursors2_0;
12110         TALLOC_CTX *_mem_save_cursors3_0;
12111         TALLOC_CTX *_mem_save_objmetadata2_0;
12112         TALLOC_CTX *_mem_save_attrvalmetadata2_0;
12113         TALLOC_CTX *_mem_save_repsto_0;
12114         TALLOC_CTX *_mem_save_clientctx_0;
12115         TALLOC_CTX *_mem_save_udv1_0;
12116         TALLOC_CTX *_mem_save_srvoutgoingcalls_0;
12117         level = ndr_pull_get_switch_value(ndr, r);
12118         if (ndr_flags & NDR_SCALARS) {
12119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12120                 if (_level != level) {
12121                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12122                 }
12123                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12124                 switch (level) {
12125                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12126                                 uint32_t _ptr_neighbours;
12127                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
12128                                 if (_ptr_neighbours) {
12129                                         NDR_PULL_ALLOC(ndr, r->neighbours);
12130                                 } else {
12131                                         r->neighbours = NULL;
12132                                 }
12133                         break; }
12134
12135                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12136                                 uint32_t _ptr_cursors;
12137                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
12138                                 if (_ptr_cursors) {
12139                                         NDR_PULL_ALLOC(ndr, r->cursors);
12140                                 } else {
12141                                         r->cursors = NULL;
12142                                 }
12143                         break; }
12144
12145                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12146                                 uint32_t _ptr_objmetadata;
12147                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
12148                                 if (_ptr_objmetadata) {
12149                                         NDR_PULL_ALLOC(ndr, r->objmetadata);
12150                                 } else {
12151                                         r->objmetadata = NULL;
12152                                 }
12153                         break; }
12154
12155                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12156                                 uint32_t _ptr_connectfailures;
12157                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
12158                                 if (_ptr_connectfailures) {
12159                                         NDR_PULL_ALLOC(ndr, r->connectfailures);
12160                                 } else {
12161                                         r->connectfailures = NULL;
12162                                 }
12163                         break; }
12164
12165                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12166                                 uint32_t _ptr_linkfailures;
12167                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
12168                                 if (_ptr_linkfailures) {
12169                                         NDR_PULL_ALLOC(ndr, r->linkfailures);
12170                                 } else {
12171                                         r->linkfailures = NULL;
12172                                 }
12173                         break; }
12174
12175                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12176                                 uint32_t _ptr_pendingops;
12177                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
12178                                 if (_ptr_pendingops) {
12179                                         NDR_PULL_ALLOC(ndr, r->pendingops);
12180                                 } else {
12181                                         r->pendingops = NULL;
12182                                 }
12183                         break; }
12184
12185                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12186                                 uint32_t _ptr_attrvalmetadata;
12187                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
12188                                 if (_ptr_attrvalmetadata) {
12189                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
12190                                 } else {
12191                                         r->attrvalmetadata = NULL;
12192                                 }
12193                         break; }
12194
12195                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12196                                 uint32_t _ptr_cursors2;
12197                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
12198                                 if (_ptr_cursors2) {
12199                                         NDR_PULL_ALLOC(ndr, r->cursors2);
12200                                 } else {
12201                                         r->cursors2 = NULL;
12202                                 }
12203                         break; }
12204
12205                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12206                                 uint32_t _ptr_cursors3;
12207                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
12208                                 if (_ptr_cursors3) {
12209                                         NDR_PULL_ALLOC(ndr, r->cursors3);
12210                                 } else {
12211                                         r->cursors3 = NULL;
12212                                 }
12213                         break; }
12214
12215                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12216                                 uint32_t _ptr_objmetadata2;
12217                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
12218                                 if (_ptr_objmetadata2) {
12219                                         NDR_PULL_ALLOC(ndr, r->objmetadata2);
12220                                 } else {
12221                                         r->objmetadata2 = NULL;
12222                                 }
12223                         break; }
12224
12225                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12226                                 uint32_t _ptr_attrvalmetadata2;
12227                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
12228                                 if (_ptr_attrvalmetadata2) {
12229                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
12230                                 } else {
12231                                         r->attrvalmetadata2 = NULL;
12232                                 }
12233                         break; }
12234
12235                         case DRSUAPI_DS_REPLICA_INFO_REPSTO: {
12236                                 uint32_t _ptr_repsto;
12237                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_repsto));
12238                                 if (_ptr_repsto) {
12239                                         NDR_PULL_ALLOC(ndr, r->repsto);
12240                                 } else {
12241                                         r->repsto = NULL;
12242                                 }
12243                         break; }
12244
12245                         case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS: {
12246                                 uint32_t _ptr_clientctx;
12247                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_clientctx));
12248                                 if (_ptr_clientctx) {
12249                                         NDR_PULL_ALLOC(ndr, r->clientctx);
12250                                 } else {
12251                                         r->clientctx = NULL;
12252                                 }
12253                         break; }
12254
12255                         case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1: {
12256                                 uint32_t _ptr_udv1;
12257                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_udv1));
12258                                 if (_ptr_udv1) {
12259                                         NDR_PULL_ALLOC(ndr, r->udv1);
12260                                 } else {
12261                                         r->udv1 = NULL;
12262                                 }
12263                         break; }
12264
12265                         case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS: {
12266                                 uint32_t _ptr_srvoutgoingcalls;
12267                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_srvoutgoingcalls));
12268                                 if (_ptr_srvoutgoingcalls) {
12269                                         NDR_PULL_ALLOC(ndr, r->srvoutgoingcalls);
12270                                 } else {
12271                                         r->srvoutgoingcalls = NULL;
12272                                 }
12273                         break; }
12274
12275                         default:
12276                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12277                 }
12278         }
12279         if (ndr_flags & NDR_BUFFERS) {
12280                 switch (level) {
12281                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12282                                 if (r->neighbours) {
12283                                         _mem_save_neighbours_0 = NDR_PULL_GET_MEM_CTX(ndr);
12284                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours, 0);
12285                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12286                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours_0, 0);
12287                                 }
12288                         break;
12289
12290                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12291                                 if (r->cursors) {
12292                                         _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
12293                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
12294                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12295                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
12296                                 }
12297                         break;
12298
12299                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12300                                 if (r->objmetadata) {
12301                                         _mem_save_objmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12302                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata, 0);
12303                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12304                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata_0, 0);
12305                                 }
12306                         break;
12307
12308                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12309                                 if (r->connectfailures) {
12310                                         _mem_save_connectfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12311                                         NDR_PULL_SET_MEM_CTX(ndr, r->connectfailures, 0);
12312                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12313                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connectfailures_0, 0);
12314                                 }
12315                         break;
12316
12317                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12318                                 if (r->linkfailures) {
12319                                         _mem_save_linkfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12320                                         NDR_PULL_SET_MEM_CTX(ndr, r->linkfailures, 0);
12321                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12322                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linkfailures_0, 0);
12323                                 }
12324                         break;
12325
12326                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12327                                 if (r->pendingops) {
12328                                         _mem_save_pendingops_0 = NDR_PULL_GET_MEM_CTX(ndr);
12329                                         NDR_PULL_SET_MEM_CTX(ndr, r->pendingops, 0);
12330                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12331                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pendingops_0, 0);
12332                                 }
12333                         break;
12334
12335                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12336                                 if (r->attrvalmetadata) {
12337                                         _mem_save_attrvalmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12338                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata, 0);
12339                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12340                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata_0, 0);
12341                                 }
12342                         break;
12343
12344                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12345                                 if (r->cursors2) {
12346                                         _mem_save_cursors2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12347                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors2, 0);
12348                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12349                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors2_0, 0);
12350                                 }
12351                         break;
12352
12353                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12354                                 if (r->cursors3) {
12355                                         _mem_save_cursors3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12356                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors3, 0);
12357                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12358                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors3_0, 0);
12359                                 }
12360                         break;
12361
12362                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12363                                 if (r->objmetadata2) {
12364                                         _mem_save_objmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12365                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata2, 0);
12366                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12367                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata2_0, 0);
12368                                 }
12369                         break;
12370
12371                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12372                                 if (r->attrvalmetadata2) {
12373                                         _mem_save_attrvalmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12374                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata2, 0);
12375                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12376                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata2_0, 0);
12377                                 }
12378                         break;
12379
12380                         case DRSUAPI_DS_REPLICA_INFO_REPSTO:
12381                                 if (r->repsto) {
12382                                         _mem_save_repsto_0 = NDR_PULL_GET_MEM_CTX(ndr);
12383                                         NDR_PULL_SET_MEM_CTX(ndr, r->repsto, 0);
12384                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->repsto));
12385                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_repsto_0, 0);
12386                                 }
12387                         break;
12388
12389                         case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS:
12390                                 if (r->clientctx) {
12391                                         _mem_save_clientctx_0 = NDR_PULL_GET_MEM_CTX(ndr);
12392                                         NDR_PULL_SET_MEM_CTX(ndr, r->clientctx, 0);
12393                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->clientctx));
12394                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_clientctx_0, 0);
12395                                 }
12396                         break;
12397
12398                         case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1:
12399                                 if (r->udv1) {
12400                                         _mem_save_udv1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12401                                         NDR_PULL_SET_MEM_CTX(ndr, r->udv1, 0);
12402                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->udv1));
12403                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_udv1_0, 0);
12404                                 }
12405                         break;
12406
12407                         case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS:
12408                                 if (r->srvoutgoingcalls) {
12409                                         _mem_save_srvoutgoingcalls_0 = NDR_PULL_GET_MEM_CTX(ndr);
12410                                         NDR_PULL_SET_MEM_CTX(ndr, r->srvoutgoingcalls, 0);
12411                                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->srvoutgoingcalls));
12412                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_srvoutgoingcalls_0, 0);
12413                                 }
12414                         break;
12415
12416                         default:
12417                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12418                 }
12419         }
12420         return NDR_ERR_SUCCESS;
12421 }
12422
12423 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaInfo *r)
12424 {
12425         int level;
12426         level = ndr_print_get_switch_value(ndr, r);
12427         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaInfo");
12428         switch (level) {
12429                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12430                         ndr_print_ptr(ndr, "neighbours", r->neighbours);
12431                         ndr->depth++;
12432                         if (r->neighbours) {
12433                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours", r->neighbours);
12434                         }
12435                         ndr->depth--;
12436                 break;
12437
12438                 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12439                         ndr_print_ptr(ndr, "cursors", r->cursors);
12440                         ndr->depth++;
12441                         if (r->cursors) {
12442                                 ndr_print_drsuapi_DsReplicaCursorCtr(ndr, "cursors", r->cursors);
12443                         }
12444                         ndr->depth--;
12445                 break;
12446
12447                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12448                         ndr_print_ptr(ndr, "objmetadata", r->objmetadata);
12449                         ndr->depth++;
12450                         if (r->objmetadata) {
12451                                 ndr_print_drsuapi_DsReplicaObjMetaDataCtr(ndr, "objmetadata", r->objmetadata);
12452                         }
12453                         ndr->depth--;
12454                 break;
12455
12456                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12457                         ndr_print_ptr(ndr, "connectfailures", r->connectfailures);
12458                         ndr->depth++;
12459                         if (r->connectfailures) {
12460                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "connectfailures", r->connectfailures);
12461                         }
12462                         ndr->depth--;
12463                 break;
12464
12465                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12466                         ndr_print_ptr(ndr, "linkfailures", r->linkfailures);
12467                         ndr->depth++;
12468                         if (r->linkfailures) {
12469                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "linkfailures", r->linkfailures);
12470                         }
12471                         ndr->depth--;
12472                 break;
12473
12474                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12475                         ndr_print_ptr(ndr, "pendingops", r->pendingops);
12476                         ndr->depth++;
12477                         if (r->pendingops) {
12478                                 ndr_print_drsuapi_DsReplicaOpCtr(ndr, "pendingops", r->pendingops);
12479                         }
12480                         ndr->depth--;
12481                 break;
12482
12483                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12484                         ndr_print_ptr(ndr, "attrvalmetadata", r->attrvalmetadata);
12485                         ndr->depth++;
12486                         if (r->attrvalmetadata) {
12487                                 ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, "attrvalmetadata", r->attrvalmetadata);
12488                         }
12489                         ndr->depth--;
12490                 break;
12491
12492                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12493                         ndr_print_ptr(ndr, "cursors2", r->cursors2);
12494                         ndr->depth++;
12495                         if (r->cursors2) {
12496                                 ndr_print_drsuapi_DsReplicaCursor2Ctr(ndr, "cursors2", r->cursors2);
12497                         }
12498                         ndr->depth--;
12499                 break;
12500
12501                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12502                         ndr_print_ptr(ndr, "cursors3", r->cursors3);
12503                         ndr->depth++;
12504                         if (r->cursors3) {
12505                                 ndr_print_drsuapi_DsReplicaCursor3Ctr(ndr, "cursors3", r->cursors3);
12506                         }
12507                         ndr->depth--;
12508                 break;
12509
12510                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12511                         ndr_print_ptr(ndr, "objmetadata2", r->objmetadata2);
12512                         ndr->depth++;
12513                         if (r->objmetadata2) {
12514                                 ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(ndr, "objmetadata2", r->objmetadata2);
12515                         }
12516                         ndr->depth--;
12517                 break;
12518
12519                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12520                         ndr_print_ptr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12521                         ndr->depth++;
12522                         if (r->attrvalmetadata2) {
12523                                 ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12524                         }
12525                         ndr->depth--;
12526                 break;
12527
12528                 case DRSUAPI_DS_REPLICA_INFO_REPSTO:
12529                         ndr_print_ptr(ndr, "repsto", r->repsto);
12530                         ndr->depth++;
12531                         if (r->repsto) {
12532                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "repsto", r->repsto);
12533                         }
12534                         ndr->depth--;
12535                 break;
12536
12537                 case DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS:
12538                         ndr_print_ptr(ndr, "clientctx", r->clientctx);
12539                         ndr->depth++;
12540                         if (r->clientctx) {
12541                                 ndr_print_drsuapi_DsReplicaConnection04Ctr(ndr, "clientctx", r->clientctx);
12542                         }
12543                         ndr->depth--;
12544                 break;
12545
12546                 case DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1:
12547                         ndr_print_ptr(ndr, "udv1", r->udv1);
12548                         ndr->depth++;
12549                         if (r->udv1) {
12550                                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "udv1", r->udv1);
12551                         }
12552                         ndr->depth--;
12553                 break;
12554
12555                 case DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS:
12556                         ndr_print_ptr(ndr, "srvoutgoingcalls", r->srvoutgoingcalls);
12557                         ndr->depth++;
12558                         if (r->srvoutgoingcalls) {
12559                                 ndr_print_drsuapi_DsReplica06Ctr(ndr, "srvoutgoingcalls", r->srvoutgoingcalls);
12560                         }
12561                         ndr->depth--;
12562                 break;
12563
12564                 default:
12565                         ndr_print_bad_level(ndr, name, level);
12566         }
12567 }
12568
12569 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Ctr *r)
12570 {
12571         if (ndr_flags & NDR_SCALARS) {
12572                 int level = ndr_push_get_switch_value(ndr, r);
12573                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12574                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12575                 switch (level) {
12576                         case 1: {
12577                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12578                         break; }
12579
12580                         default:
12581                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12582                 }
12583         }
12584         if (ndr_flags & NDR_BUFFERS) {
12585                 int level = ndr_push_get_switch_value(ndr, r);
12586                 switch (level) {
12587                         case 1:
12588                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12589                         break;
12590
12591                         default:
12592                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12593                 }
12594         }
12595         return NDR_ERR_SUCCESS;
12596 }
12597
12598 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Ctr *r)
12599 {
12600         int level;
12601         int32_t _level;
12602         level = ndr_pull_get_switch_value(ndr, r);
12603         if (ndr_flags & NDR_SCALARS) {
12604                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12605                 if (_level != level) {
12606                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12607                 }
12608                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12609                 switch (level) {
12610                         case 1: {
12611                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12612                         break; }
12613
12614                         default:
12615                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12616                 }
12617         }
12618         if (ndr_flags & NDR_BUFFERS) {
12619                 switch (level) {
12620                         case 1:
12621                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12622                         break;
12623
12624                         default:
12625                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12626                 }
12627         }
12628         return NDR_ERR_SUCCESS;
12629 }
12630
12631 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Ctr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Ctr *r)
12632 {
12633         int level;
12634         level = ndr_print_get_switch_value(ndr, r);
12635         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Ctr");
12636         switch (level) {
12637                 case 1:
12638                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
12639                 break;
12640
12641                 default:
12642                         ndr_print_bad_level(ndr, name, level);
12643         }
12644 }
12645
12646 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMemberships2Request1 *r)
12647 {
12648         uint32_t cntr_req_array_1;
12649         if (ndr_flags & NDR_SCALARS) {
12650                 NDR_CHECK(ndr_push_align(ndr, 5));
12651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12652                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
12653                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12654         }
12655         if (ndr_flags & NDR_BUFFERS) {
12656                 if (r->req_array) {
12657                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
12658                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12659                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
12660                         }
12661                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12662                                 if (r->req_array[cntr_req_array_1]) {
12663                                         NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12664                                 }
12665                         }
12666                 }
12667         }
12668         return NDR_ERR_SUCCESS;
12669 }
12670
12671 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
12672 {
12673         uint32_t _ptr_req_array;
12674         uint32_t cntr_req_array_1;
12675         TALLOC_CTX *_mem_save_req_array_0;
12676         TALLOC_CTX *_mem_save_req_array_1;
12677         TALLOC_CTX *_mem_save_req_array_2;
12678         if (ndr_flags & NDR_SCALARS) {
12679                 NDR_CHECK(ndr_pull_align(ndr, 5));
12680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12681                 if (r->num_req < 1 || r->num_req > 10000) {
12682                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12683                 }
12684                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12685                 if (_ptr_req_array) {
12686                         NDR_PULL_ALLOC(ndr, r->req_array);
12687                 } else {
12688                         r->req_array = NULL;
12689                 }
12690                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12691         }
12692         if (ndr_flags & NDR_BUFFERS) {
12693                 if (r->req_array) {
12694                         _mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12695                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12696                         NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
12697                         NDR_PULL_ALLOC_N(ndr, r->req_array, ndr_get_array_size(ndr, &r->req_array));
12698                         _mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12699                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12700                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12701                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12702                                 if (_ptr_req_array) {
12703                                         NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
12704                                 } else {
12705                                         r->req_array[cntr_req_array_1] = NULL;
12706                                 }
12707                         }
12708                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12709                                 if (r->req_array[cntr_req_array_1]) {
12710                                         _mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
12711                                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
12712                                         NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12713                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_2, 0);
12714                                 }
12715                         }
12716                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_1, 0);
12717                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_0, 0);
12718                 }
12719                 if (r->req_array) {
12720                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->req_array, r->num_req));
12721                 }
12722         }
12723         return NDR_ERR_SUCCESS;
12724 }
12725
12726 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMemberships2Request1 *r)
12727 {
12728         uint32_t cntr_req_array_1;
12729         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2Request1");
12730         ndr->depth++;
12731         ndr_print_uint32(ndr, "num_req", r->num_req);
12732         ndr_print_ptr(ndr, "req_array", r->req_array);
12733         ndr->depth++;
12734         if (r->req_array) {
12735                 ndr->print(ndr, "%s: ARRAY(%d)", "req_array", (int)r->num_req);
12736                 ndr->depth++;
12737                 for (cntr_req_array_1=0;cntr_req_array_1<r->num_req;cntr_req_array_1++) {
12738                         char *idx_1=NULL;
12739                         if (asprintf(&idx_1, "[%d]", cntr_req_array_1) != -1) {
12740                                 ndr_print_ptr(ndr, "req_array", r->req_array[cntr_req_array_1]);
12741                                 ndr->depth++;
12742                                 if (r->req_array[cntr_req_array_1]) {
12743                                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req_array", r->req_array[cntr_req_array_1]);
12744                                 }
12745                                 ndr->depth--;
12746                                 free(idx_1);
12747                         }
12748                 }
12749                 ndr->depth--;
12750         }
12751         ndr->depth--;
12752         ndr->depth--;
12753 }
12754
12755 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Request *r)
12756 {
12757         if (ndr_flags & NDR_SCALARS) {
12758                 int level = ndr_push_get_switch_value(ndr, r);
12759                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12760                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12761                 switch (level) {
12762                         case 1: {
12763                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12764                         break; }
12765
12766                         default:
12767                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12768                 }
12769         }
12770         if (ndr_flags & NDR_BUFFERS) {
12771                 int level = ndr_push_get_switch_value(ndr, r);
12772                 switch (level) {
12773                         case 1:
12774                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12775                         break;
12776
12777                         default:
12778                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12779                 }
12780         }
12781         return NDR_ERR_SUCCESS;
12782 }
12783
12784 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Request *r)
12785 {
12786         int level;
12787         int32_t _level;
12788         level = ndr_pull_get_switch_value(ndr, r);
12789         if (ndr_flags & NDR_SCALARS) {
12790                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12791                 if (_level != level) {
12792                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12793                 }
12794                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12795                 switch (level) {
12796                         case 1: {
12797                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12798                         break; }
12799
12800                         default:
12801                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12802                 }
12803         }
12804         if (ndr_flags & NDR_BUFFERS) {
12805                 switch (level) {
12806                         case 1:
12807                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12808                         break;
12809
12810                         default:
12811                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12812                 }
12813         }
12814         return NDR_ERR_SUCCESS;
12815 }
12816
12817 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Request *r)
12818 {
12819         int level;
12820         level = ndr_print_get_switch_value(ndr, r);
12821         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Request");
12822         switch (level) {
12823                 case 1:
12824                         ndr_print_drsuapi_DsGetMemberships2Request1(ndr, "req1", &r->req1);
12825                 break;
12826
12827                 default:
12828                         ndr_print_bad_level(ndr, name, level);
12829         }
12830 }
12831
12832 static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsSiteCostInfo *r)
12833 {
12834         if (ndr_flags & NDR_SCALARS) {
12835                 NDR_CHECK(ndr_push_align(ndr, 4));
12836                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
12837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
12838                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
12839         }
12840         if (ndr_flags & NDR_BUFFERS) {
12841         }
12842         return NDR_ERR_SUCCESS;
12843 }
12844
12845 static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsSiteCostInfo *r)
12846 {
12847         if (ndr_flags & NDR_SCALARS) {
12848                 NDR_CHECK(ndr_pull_align(ndr, 4));
12849                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
12850                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
12851                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
12852         }
12853         if (ndr_flags & NDR_BUFFERS) {
12854         }
12855         return NDR_ERR_SUCCESS;
12856 }
12857
12858 _PUBLIC_ void ndr_print_drsuapi_DsSiteCostInfo(struct ndr_print *ndr, const char *name, const struct drsuapi_DsSiteCostInfo *r)
12859 {
12860         ndr_print_struct(ndr, name, "drsuapi_DsSiteCostInfo");
12861         ndr->depth++;
12862         ndr_print_WERROR(ndr, "error_code", r->error_code);
12863         ndr_print_uint32(ndr, "site_cost", r->site_cost);
12864         ndr->depth--;
12865 }
12866
12867 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostCtr1 *r)
12868 {
12869         uint32_t cntr_info_1;
12870         if (ndr_flags & NDR_SCALARS) {
12871                 NDR_CHECK(ndr_push_align(ndr, 5));
12872                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
12873                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
12874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
12875                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12876         }
12877         if (ndr_flags & NDR_BUFFERS) {
12878                 if (r->info) {
12879                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_info));
12880                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12881                                 NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12882                         }
12883                 }
12884         }
12885         return NDR_ERR_SUCCESS;
12886 }
12887
12888 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
12889 {
12890         uint32_t _ptr_info;
12891         uint32_t cntr_info_1;
12892         TALLOC_CTX *_mem_save_info_0;
12893         TALLOC_CTX *_mem_save_info_1;
12894         if (ndr_flags & NDR_SCALARS) {
12895                 NDR_CHECK(ndr_pull_align(ndr, 5));
12896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
12897                 if (r->num_info > 10000) {
12898                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12899                 }
12900                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12901                 if (_ptr_info) {
12902                         NDR_PULL_ALLOC(ndr, r->info);
12903                 } else {
12904                         r->info = NULL;
12905                 }
12906                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
12907                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12908         }
12909         if (ndr_flags & NDR_BUFFERS) {
12910                 if (r->info) {
12911                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12912                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12913                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
12914                         NDR_PULL_ALLOC_N(ndr, r->info, ndr_get_array_size(ndr, &r->info));
12915                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
12916                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12917                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12918                                 NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12919                         }
12920                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
12921                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12922                 }
12923                 if (r->info) {
12924                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info, r->num_info));
12925                 }
12926         }
12927         return NDR_ERR_SUCCESS;
12928 }
12929
12930 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostCtr1 *r)
12931 {
12932         uint32_t cntr_info_1;
12933         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostCtr1");
12934         ndr->depth++;
12935         ndr_print_uint32(ndr, "num_info", r->num_info);
12936         ndr_print_ptr(ndr, "info", r->info);
12937         ndr->depth++;
12938         if (r->info) {
12939                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->num_info);
12940                 ndr->depth++;
12941                 for (cntr_info_1=0;cntr_info_1<r->num_info;cntr_info_1++) {
12942                         char *idx_1=NULL;
12943                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12944                                 ndr_print_drsuapi_DsSiteCostInfo(ndr, "info", &r->info[cntr_info_1]);
12945                                 free(idx_1);
12946                         }
12947                 }
12948                 ndr->depth--;
12949         }
12950         ndr->depth--;
12951         ndr_print_uint32(ndr, "unknown", r->unknown);
12952         ndr->depth--;
12953 }
12954
12955 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostCtr *r)
12956 {
12957         if (ndr_flags & NDR_SCALARS) {
12958                 int level = ndr_push_get_switch_value(ndr, r);
12959                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12960                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12961                 switch (level) {
12962                         case 1: {
12963                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12964                         break; }
12965
12966                         default:
12967                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12968                 }
12969         }
12970         if (ndr_flags & NDR_BUFFERS) {
12971                 int level = ndr_push_get_switch_value(ndr, r);
12972                 switch (level) {
12973                         case 1:
12974                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12975                         break;
12976
12977                         default:
12978                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12979                 }
12980         }
12981         return NDR_ERR_SUCCESS;
12982 }
12983
12984 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostCtr *r)
12985 {
12986         int level;
12987         int32_t _level;
12988         level = ndr_pull_get_switch_value(ndr, r);
12989         if (ndr_flags & NDR_SCALARS) {
12990                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12991                 if (_level != level) {
12992                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12993                 }
12994                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12995                 switch (level) {
12996                         case 1: {
12997                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12998                         break; }
12999
13000                         default:
13001                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13002                 }
13003         }
13004         if (ndr_flags & NDR_BUFFERS) {
13005                 switch (level) {
13006                         case 1:
13007                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
13008                         break;
13009
13010                         default:
13011                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13012                 }
13013         }
13014         return NDR_ERR_SUCCESS;
13015 }
13016
13017 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostCtr *r)
13018 {
13019         int level;
13020         level = ndr_print_get_switch_value(ndr, r);
13021         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostCtr");
13022         switch (level) {
13023                 case 1:
13024                         ndr_print_drsuapi_QuerySitesByCostCtr1(ndr, "ctr1", &r->ctr1);
13025                 break;
13026
13027                 default:
13028                         ndr_print_bad_level(ndr, name, level);
13029         }
13030 }
13031
13032 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostRequest1 *r)
13033 {
13034         uint32_t cntr_site_to_1;
13035         if (ndr_flags & NDR_SCALARS) {
13036                 NDR_CHECK(ndr_push_align(ndr, 5));
13037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
13038                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
13039                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
13040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13041                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13042         }
13043         if (ndr_flags & NDR_BUFFERS) {
13044                 if (r->site_from) {
13045                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13046                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13047                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13048                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13049                 }
13050                 if (r->site_to) {
13051                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
13052                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13053                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
13054                         }
13055                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13056                                 if (r->site_to[cntr_site_to_1]) {
13057                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13058                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13059                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13060                                         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));
13061                                 }
13062                         }
13063                 }
13064         }
13065         return NDR_ERR_SUCCESS;
13066 }
13067
13068 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
13069 {
13070         uint32_t _ptr_site_from;
13071         TALLOC_CTX *_mem_save_site_from_0;
13072         uint32_t _ptr_site_to;
13073         uint32_t cntr_site_to_1;
13074         TALLOC_CTX *_mem_save_site_to_0;
13075         TALLOC_CTX *_mem_save_site_to_1;
13076         TALLOC_CTX *_mem_save_site_to_2;
13077         if (ndr_flags & NDR_SCALARS) {
13078                 NDR_CHECK(ndr_pull_align(ndr, 5));
13079                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
13080                 if (_ptr_site_from) {
13081                         NDR_PULL_ALLOC(ndr, r->site_from);
13082                 } else {
13083                         r->site_from = NULL;
13084                 }
13085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
13086                 if (r->num_req < 1 || r->num_req > 10000) {
13087                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
13088                 }
13089                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13090                 if (_ptr_site_to) {
13091                         NDR_PULL_ALLOC(ndr, r->site_to);
13092                 } else {
13093                         r->site_to = NULL;
13094                 }
13095                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13096                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13097         }
13098         if (ndr_flags & NDR_BUFFERS) {
13099                 if (r->site_from) {
13100                         _mem_save_site_from_0 = NDR_PULL_GET_MEM_CTX(ndr);
13101                         NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
13102                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
13103                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
13104                         if (ndr_get_array_length(ndr, &r->site_from) > ndr_get_array_size(ndr, &r->site_from)) {
13105                                 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));
13106                         }
13107                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t)));
13108                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t), CH_UTF16));
13109                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
13110                 }
13111                 if (r->site_to) {
13112                         _mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
13113                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13114                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
13115                         NDR_PULL_ALLOC_N(ndr, r->site_to, ndr_get_array_size(ndr, &r->site_to));
13116                         _mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
13117                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13118                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13119                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13120                                 if (_ptr_site_to) {
13121                                         NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
13122                                 } else {
13123                                         r->site_to[cntr_site_to_1] = NULL;
13124                                 }
13125                         }
13126                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13127                                 if (r->site_to[cntr_site_to_1]) {
13128                                         _mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
13129                                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
13130                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
13131                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
13132                                         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])) {
13133                                                 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]));
13134                                         }
13135                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t)));
13136                                         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));
13137                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
13138                                 }
13139                         }
13140                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_1, 0);
13141                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_0, 0);
13142                 }
13143                 if (r->site_to) {
13144                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->site_to, r->num_req));
13145                 }
13146         }
13147         return NDR_ERR_SUCCESS;
13148 }
13149
13150 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostRequest1 *r)
13151 {
13152         uint32_t cntr_site_to_1;
13153         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostRequest1");
13154         ndr->depth++;
13155         ndr_print_ptr(ndr, "site_from", r->site_from);
13156         ndr->depth++;
13157         if (r->site_from) {
13158                 ndr_print_string(ndr, "site_from", r->site_from);
13159         }
13160         ndr->depth--;
13161         ndr_print_uint32(ndr, "num_req", r->num_req);
13162         ndr_print_ptr(ndr, "site_to", r->site_to);
13163         ndr->depth++;
13164         if (r->site_to) {
13165                 ndr->print(ndr, "%s: ARRAY(%d)", "site_to", (int)r->num_req);
13166                 ndr->depth++;
13167                 for (cntr_site_to_1=0;cntr_site_to_1<r->num_req;cntr_site_to_1++) {
13168                         char *idx_1=NULL;
13169                         if (asprintf(&idx_1, "[%d]", cntr_site_to_1) != -1) {
13170                                 ndr_print_ptr(ndr, "site_to", r->site_to[cntr_site_to_1]);
13171                                 ndr->depth++;
13172                                 if (r->site_to[cntr_site_to_1]) {
13173                                         ndr_print_string(ndr, "site_to", r->site_to[cntr_site_to_1]);
13174                                 }
13175                                 ndr->depth--;
13176                                 free(idx_1);
13177                         }
13178                 }
13179                 ndr->depth--;
13180         }
13181         ndr->depth--;
13182         ndr_print_uint32(ndr, "flags", r->flags);
13183         ndr->depth--;
13184 }
13185
13186 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostRequest *r)
13187 {
13188         if (ndr_flags & NDR_SCALARS) {
13189                 int level = ndr_push_get_switch_value(ndr, r);
13190                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13191                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13192                 switch (level) {
13193                         case 1: {
13194                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13195                         break; }
13196
13197                         default:
13198                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13199                 }
13200         }
13201         if (ndr_flags & NDR_BUFFERS) {
13202                 int level = ndr_push_get_switch_value(ndr, r);
13203                 switch (level) {
13204                         case 1:
13205                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13206                         break;
13207
13208                         default:
13209                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13210                 }
13211         }
13212         return NDR_ERR_SUCCESS;
13213 }
13214
13215 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostRequest *r)
13216 {
13217         int level;
13218         int32_t _level;
13219         level = ndr_pull_get_switch_value(ndr, r);
13220         if (ndr_flags & NDR_SCALARS) {
13221                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13222                 if (_level != level) {
13223                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13224                 }
13225                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13226                 switch (level) {
13227                         case 1: {
13228                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13229                         break; }
13230
13231                         default:
13232                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13233                 }
13234         }
13235         if (ndr_flags & NDR_BUFFERS) {
13236                 switch (level) {
13237                         case 1:
13238                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13239                         break;
13240
13241                         default:
13242                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13243                 }
13244         }
13245         return NDR_ERR_SUCCESS;
13246 }
13247
13248 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostRequest *r)
13249 {
13250         int level;
13251         level = ndr_print_get_switch_value(ndr, r);
13252         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostRequest");
13253         switch (level) {
13254                 case 1:
13255                         ndr_print_drsuapi_QuerySitesByCostRequest1(ndr, "req1", &r->req1);
13256                 break;
13257
13258                 default:
13259                         ndr_print_bad_level(ndr, name, level);
13260         }
13261 }
13262
13263 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsBind(struct ndr_push *ndr, int flags, const struct drsuapi_DsBind *r)
13264 {
13265         if (flags & NDR_IN) {
13266                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_guid));
13267                 if (r->in.bind_guid) {
13268                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13269                 }
13270                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_info));
13271                 if (r->in.bind_info) {
13272                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13273                 }
13274         }
13275         if (flags & NDR_OUT) {
13276                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.bind_info));
13277                 if (r->out.bind_info) {
13278                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13279                 }
13280                 if (r->out.bind_handle == NULL) {
13281                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13282                 }
13283                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13284                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13285         }
13286         return NDR_ERR_SUCCESS;
13287 }
13288
13289 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsBind(struct ndr_pull *ndr, int flags, struct drsuapi_DsBind *r)
13290 {
13291         uint32_t _ptr_bind_guid;
13292         uint32_t _ptr_bind_info;
13293         TALLOC_CTX *_mem_save_bind_guid_0;
13294         TALLOC_CTX *_mem_save_bind_info_0;
13295         TALLOC_CTX *_mem_save_bind_handle_0;
13296         if (flags & NDR_IN) {
13297                 ZERO_STRUCT(r->out);
13298
13299                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_guid));
13300                 if (_ptr_bind_guid) {
13301                         NDR_PULL_ALLOC(ndr, r->in.bind_guid);
13302                 } else {
13303                         r->in.bind_guid = NULL;
13304                 }
13305                 if (r->in.bind_guid) {
13306                         _mem_save_bind_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
13307                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_guid, 0);
13308                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13309                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_guid_0, 0);
13310                 }
13311                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13312                 if (_ptr_bind_info) {
13313                         NDR_PULL_ALLOC(ndr, r->in.bind_info);
13314                 } else {
13315                         r->in.bind_info = NULL;
13316                 }
13317                 if (r->in.bind_info) {
13318                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13319                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_info, 0);
13320                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13321                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13322                 }
13323                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13324                 ZERO_STRUCTP(r->out.bind_handle);
13325         }
13326         if (flags & NDR_OUT) {
13327                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13328                 if (_ptr_bind_info) {
13329                         NDR_PULL_ALLOC(ndr, r->out.bind_info);
13330                 } else {
13331                         r->out.bind_info = NULL;
13332                 }
13333                 if (r->out.bind_info) {
13334                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13335                         NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_info, 0);
13336                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13337                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13338                 }
13339                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13340                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13341                 }
13342                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13343                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13344                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13345                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13346                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13347         }
13348         return NDR_ERR_SUCCESS;
13349 }
13350
13351 _PUBLIC_ void ndr_print_drsuapi_DsBind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsBind *r)
13352 {
13353         ndr_print_struct(ndr, name, "drsuapi_DsBind");
13354         ndr->depth++;
13355         if (flags & NDR_SET_VALUES) {
13356                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13357         }
13358         if (flags & NDR_IN) {
13359                 ndr_print_struct(ndr, "in", "drsuapi_DsBind");
13360                 ndr->depth++;
13361                 ndr_print_ptr(ndr, "bind_guid", r->in.bind_guid);
13362                 ndr->depth++;
13363                 if (r->in.bind_guid) {
13364                         ndr_print_GUID(ndr, "bind_guid", r->in.bind_guid);
13365                 }
13366                 ndr->depth--;
13367                 ndr_print_ptr(ndr, "bind_info", r->in.bind_info);
13368                 ndr->depth++;
13369                 if (r->in.bind_info) {
13370                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->in.bind_info);
13371                 }
13372                 ndr->depth--;
13373                 ndr->depth--;
13374         }
13375         if (flags & NDR_OUT) {
13376                 ndr_print_struct(ndr, "out", "drsuapi_DsBind");
13377                 ndr->depth++;
13378                 ndr_print_ptr(ndr, "bind_info", r->out.bind_info);
13379                 ndr->depth++;
13380                 if (r->out.bind_info) {
13381                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->out.bind_info);
13382                 }
13383                 ndr->depth--;
13384                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13385                 ndr->depth++;
13386                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13387                 ndr->depth--;
13388                 ndr_print_WERROR(ndr, "result", r->out.result);
13389                 ndr->depth--;
13390         }
13391         ndr->depth--;
13392 }
13393
13394 static enum ndr_err_code ndr_push_drsuapi_DsUnbind(struct ndr_push *ndr, int flags, const struct drsuapi_DsUnbind *r)
13395 {
13396         if (flags & NDR_IN) {
13397                 if (r->in.bind_handle == NULL) {
13398                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13399                 }
13400                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13401         }
13402         if (flags & NDR_OUT) {
13403                 if (r->out.bind_handle == NULL) {
13404                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13405                 }
13406                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13407                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13408         }
13409         return NDR_ERR_SUCCESS;
13410 }
13411
13412 static enum ndr_err_code ndr_pull_drsuapi_DsUnbind(struct ndr_pull *ndr, int flags, struct drsuapi_DsUnbind *r)
13413 {
13414         TALLOC_CTX *_mem_save_bind_handle_0;
13415         if (flags & NDR_IN) {
13416                 ZERO_STRUCT(r->out);
13417
13418                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13419                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13420                 }
13421                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13422                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13423                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13424                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13425                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13426                 *r->out.bind_handle = *r->in.bind_handle;
13427         }
13428         if (flags & NDR_OUT) {
13429                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13430                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13431                 }
13432                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13433                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13434                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13435                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13436                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13437         }
13438         return NDR_ERR_SUCCESS;
13439 }
13440
13441 _PUBLIC_ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsUnbind *r)
13442 {
13443         ndr_print_struct(ndr, name, "drsuapi_DsUnbind");
13444         ndr->depth++;
13445         if (flags & NDR_SET_VALUES) {
13446                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13447         }
13448         if (flags & NDR_IN) {
13449                 ndr_print_struct(ndr, "in", "drsuapi_DsUnbind");
13450                 ndr->depth++;
13451                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13452                 ndr->depth++;
13453                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13454                 ndr->depth--;
13455                 ndr->depth--;
13456         }
13457         if (flags & NDR_OUT) {
13458                 ndr_print_struct(ndr, "out", "drsuapi_DsUnbind");
13459                 ndr->depth++;
13460                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13461                 ndr->depth++;
13462                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13463                 ndr->depth--;
13464                 ndr_print_WERROR(ndr, "result", r->out.result);
13465                 ndr->depth--;
13466         }
13467         ndr->depth--;
13468 }
13469
13470 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSync(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaSync *r)
13471 {
13472         if (flags & NDR_IN) {
13473                 if (r->in.bind_handle == NULL) {
13474                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13475                 }
13476                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13477                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13478                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13479                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13480         }
13481         if (flags & NDR_OUT) {
13482                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13483         }
13484         return NDR_ERR_SUCCESS;
13485 }
13486
13487 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSync(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaSync *r)
13488 {
13489         TALLOC_CTX *_mem_save_bind_handle_0;
13490         if (flags & NDR_IN) {
13491                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13492                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13493                 }
13494                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13495                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13496                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13497                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13498                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13499                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13500                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13501         }
13502         if (flags & NDR_OUT) {
13503                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13504         }
13505         return NDR_ERR_SUCCESS;
13506 }
13507
13508 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r)
13509 {
13510         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSync");
13511         ndr->depth++;
13512         if (flags & NDR_SET_VALUES) {
13513                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13514         }
13515         if (flags & NDR_IN) {
13516                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaSync");
13517                 ndr->depth++;
13518                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13519                 ndr->depth++;
13520                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13521                 ndr->depth--;
13522                 ndr_print_int32(ndr, "level", r->in.level);
13523                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13524                 ndr_print_drsuapi_DsReplicaSyncRequest(ndr, "req", &r->in.req);
13525                 ndr->depth--;
13526         }
13527         if (flags & NDR_OUT) {
13528                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaSync");
13529                 ndr->depth++;
13530                 ndr_print_WERROR(ndr, "result", r->out.result);
13531                 ndr->depth--;
13532         }
13533         ndr->depth--;
13534 }
13535
13536 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChanges(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNCChanges *r)
13537 {
13538         if (flags & NDR_IN) {
13539                 if (r->in.bind_handle == NULL) {
13540                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13541                 }
13542                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13543                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13544                 if (r->in.req == NULL) {
13545                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13546                 }
13547                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13548                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13549         }
13550         if (flags & NDR_OUT) {
13551                 if (r->out.level_out == NULL) {
13552                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13553                 }
13554                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13555                 if (r->out.ctr == NULL) {
13556                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13557                 }
13558                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13559                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13560                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13561         }
13562         return NDR_ERR_SUCCESS;
13563 }
13564
13565 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChanges(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNCChanges *r)
13566 {
13567         TALLOC_CTX *_mem_save_bind_handle_0;
13568         TALLOC_CTX *_mem_save_req_0;
13569         TALLOC_CTX *_mem_save_level_out_0;
13570         TALLOC_CTX *_mem_save_ctr_0;
13571         if (flags & NDR_IN) {
13572                 ZERO_STRUCT(r->out);
13573
13574                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13575                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13576                 }
13577                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13578                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13579                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13580                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13581                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13582                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13583                         NDR_PULL_ALLOC(ndr, r->in.req);
13584                 }
13585                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13586                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13587                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13588                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13589                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13590                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13591                 ZERO_STRUCTP(r->out.level_out);
13592                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13593                 ZERO_STRUCTP(r->out.ctr);
13594         }
13595         if (flags & NDR_OUT) {
13596                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13597                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13598                 }
13599                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13600                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13601                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13602                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13603                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13604                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13605                 }
13606                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13607                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13608                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13609                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13610                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13611                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13612         }
13613         return NDR_ERR_SUCCESS;
13614 }
13615
13616 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r)
13617 {
13618         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChanges");
13619         ndr->depth++;
13620         if (flags & NDR_SET_VALUES) {
13621                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13622         }
13623         if (flags & NDR_IN) {
13624                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNCChanges");
13625                 ndr->depth++;
13626                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13627                 ndr->depth++;
13628                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13629                 ndr->depth--;
13630                 ndr_print_int32(ndr, "level", r->in.level);
13631                 ndr_print_ptr(ndr, "req", r->in.req);
13632                 ndr->depth++;
13633                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13634                 ndr_print_drsuapi_DsGetNCChangesRequest(ndr, "req", r->in.req);
13635                 ndr->depth--;
13636                 ndr->depth--;
13637         }
13638         if (flags & NDR_OUT) {
13639                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNCChanges");
13640                 ndr->depth++;
13641                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13642                 ndr->depth++;
13643                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13644                 ndr->depth--;
13645                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13646                 ndr->depth++;
13647                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13648                 ndr_print_drsuapi_DsGetNCChangesCtr(ndr, "ctr", r->out.ctr);
13649                 ndr->depth--;
13650                 ndr_print_WERROR(ndr, "result", r->out.result);
13651                 ndr->depth--;
13652         }
13653         ndr->depth--;
13654 }
13655
13656 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefs(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13657 {
13658         if (flags & NDR_IN) {
13659                 if (r->in.bind_handle == NULL) {
13660                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13661                 }
13662                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13663                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13664                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13665                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13666         }
13667         if (flags & NDR_OUT) {
13668                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13669         }
13670         return NDR_ERR_SUCCESS;
13671 }
13672
13673 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefs(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaUpdateRefs *r)
13674 {
13675         TALLOC_CTX *_mem_save_bind_handle_0;
13676         if (flags & NDR_IN) {
13677                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13678                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13679                 }
13680                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13681                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13682                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13683                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13684                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13685                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13686                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13687         }
13688         if (flags & NDR_OUT) {
13689                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13690         }
13691         return NDR_ERR_SUCCESS;
13692 }
13693
13694 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13695 {
13696         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefs");
13697         ndr->depth++;
13698         if (flags & NDR_SET_VALUES) {
13699                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13700         }
13701         if (flags & NDR_IN) {
13702                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaUpdateRefs");
13703                 ndr->depth++;
13704                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13705                 ndr->depth++;
13706                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13707                 ndr->depth--;
13708                 ndr_print_int32(ndr, "level", r->in.level);
13709                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13710                 ndr_print_drsuapi_DsReplicaUpdateRefsRequest(ndr, "req", &r->in.req);
13711                 ndr->depth--;
13712         }
13713         if (flags & NDR_OUT) {
13714                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaUpdateRefs");
13715                 ndr->depth++;
13716                 ndr_print_WERROR(ndr, "result", r->out.result);
13717                 ndr->depth--;
13718         }
13719         ndr->depth--;
13720 }
13721
13722 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAdd(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaAdd *r)
13723 {
13724         if (flags & NDR_IN) {
13725                 if (r->in.bind_handle == NULL) {
13726                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13727                 }
13728                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13729                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13730                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13731                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13732         }
13733         if (flags & NDR_OUT) {
13734                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13735         }
13736         return NDR_ERR_SUCCESS;
13737 }
13738
13739 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAdd(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaAdd *r)
13740 {
13741         TALLOC_CTX *_mem_save_bind_handle_0;
13742         if (flags & NDR_IN) {
13743                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13744                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13745                 }
13746                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13747                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13748                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13749                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13750                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13751                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13752                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13753         }
13754         if (flags & NDR_OUT) {
13755                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13756         }
13757         return NDR_ERR_SUCCESS;
13758 }
13759
13760 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r)
13761 {
13762         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAdd");
13763         ndr->depth++;
13764         if (flags & NDR_SET_VALUES) {
13765                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13766         }
13767         if (flags & NDR_IN) {
13768                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaAdd");
13769                 ndr->depth++;
13770                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13771                 ndr->depth++;
13772                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13773                 ndr->depth--;
13774                 ndr_print_int32(ndr, "level", r->in.level);
13775                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13776                 ndr_print_drsuapi_DsReplicaAddRequest(ndr, "req", &r->in.req);
13777                 ndr->depth--;
13778         }
13779         if (flags & NDR_OUT) {
13780                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaAdd");
13781                 ndr->depth++;
13782                 ndr_print_WERROR(ndr, "result", r->out.result);
13783                 ndr->depth--;
13784         }
13785         ndr->depth--;
13786 }
13787
13788 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDel(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaDel *r)
13789 {
13790         if (flags & NDR_IN) {
13791                 if (r->in.bind_handle == NULL) {
13792                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13793                 }
13794                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13795                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13796                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13797                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13798         }
13799         if (flags & NDR_OUT) {
13800                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13801         }
13802         return NDR_ERR_SUCCESS;
13803 }
13804
13805 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDel(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaDel *r)
13806 {
13807         TALLOC_CTX *_mem_save_bind_handle_0;
13808         if (flags & NDR_IN) {
13809                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13810                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13811                 }
13812                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13813                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13814                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13815                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13816                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13817                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13818                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13819         }
13820         if (flags & NDR_OUT) {
13821                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13822         }
13823         return NDR_ERR_SUCCESS;
13824 }
13825
13826 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r)
13827 {
13828         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDel");
13829         ndr->depth++;
13830         if (flags & NDR_SET_VALUES) {
13831                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13832         }
13833         if (flags & NDR_IN) {
13834                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaDel");
13835                 ndr->depth++;
13836                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13837                 ndr->depth++;
13838                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13839                 ndr->depth--;
13840                 ndr_print_int32(ndr, "level", r->in.level);
13841                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13842                 ndr_print_drsuapi_DsReplicaDelRequest(ndr, "req", &r->in.req);
13843                 ndr->depth--;
13844         }
13845         if (flags & NDR_OUT) {
13846                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaDel");
13847                 ndr->depth++;
13848                 ndr_print_WERROR(ndr, "result", r->out.result);
13849                 ndr->depth--;
13850         }
13851         ndr->depth--;
13852 }
13853
13854 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMod(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaMod *r)
13855 {
13856         if (flags & NDR_IN) {
13857                 if (r->in.bind_handle == NULL) {
13858                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13859                 }
13860                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13861                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13862                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13863                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13864         }
13865         if (flags & NDR_OUT) {
13866                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13867         }
13868         return NDR_ERR_SUCCESS;
13869 }
13870
13871 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMod(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaMod *r)
13872 {
13873         TALLOC_CTX *_mem_save_bind_handle_0;
13874         if (flags & NDR_IN) {
13875                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13876                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13877                 }
13878                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13879                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13880                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13881                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13882                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13883                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13884                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13885         }
13886         if (flags & NDR_OUT) {
13887                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13888         }
13889         return NDR_ERR_SUCCESS;
13890 }
13891
13892 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r)
13893 {
13894         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMod");
13895         ndr->depth++;
13896         if (flags & NDR_SET_VALUES) {
13897                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13898         }
13899         if (flags & NDR_IN) {
13900                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaMod");
13901                 ndr->depth++;
13902                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13903                 ndr->depth++;
13904                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13905                 ndr->depth--;
13906                 ndr_print_int32(ndr, "level", r->in.level);
13907                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13908                 ndr_print_drsuapi_DsReplicaModRequest(ndr, "req", &r->in.req);
13909                 ndr->depth--;
13910         }
13911         if (flags & NDR_OUT) {
13912                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaMod");
13913                 ndr->depth++;
13914                 ndr_print_WERROR(ndr, "result", r->out.result);
13915                 ndr->depth--;
13916         }
13917         ndr->depth--;
13918 }
13919
13920 static enum ndr_err_code ndr_push_DRSUAPI_VERIFY_NAMES(struct ndr_push *ndr, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13921 {
13922         if (flags & NDR_IN) {
13923         }
13924         if (flags & NDR_OUT) {
13925                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13926         }
13927         return NDR_ERR_SUCCESS;
13928 }
13929
13930 static enum ndr_err_code ndr_pull_DRSUAPI_VERIFY_NAMES(struct ndr_pull *ndr, int flags, struct DRSUAPI_VERIFY_NAMES *r)
13931 {
13932         if (flags & NDR_IN) {
13933         }
13934         if (flags & NDR_OUT) {
13935                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13936         }
13937         return NDR_ERR_SUCCESS;
13938 }
13939
13940 _PUBLIC_ void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13941 {
13942         ndr_print_struct(ndr, name, "DRSUAPI_VERIFY_NAMES");
13943         ndr->depth++;
13944         if (flags & NDR_SET_VALUES) {
13945                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13946         }
13947         if (flags & NDR_IN) {
13948                 ndr_print_struct(ndr, "in", "DRSUAPI_VERIFY_NAMES");
13949                 ndr->depth++;
13950                 ndr->depth--;
13951         }
13952         if (flags & NDR_OUT) {
13953                 ndr_print_struct(ndr, "out", "DRSUAPI_VERIFY_NAMES");
13954                 ndr->depth++;
13955                 ndr_print_WERROR(ndr, "result", r->out.result);
13956                 ndr->depth--;
13957         }
13958         ndr->depth--;
13959 }
13960
13961 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships *r)
13962 {
13963         if (flags & NDR_IN) {
13964                 if (r->in.bind_handle == NULL) {
13965                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13966                 }
13967                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13968                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13969                 if (r->in.req == NULL) {
13970                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13971                 }
13972                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13973                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13974         }
13975         if (flags & NDR_OUT) {
13976                 if (r->out.level_out == NULL) {
13977                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13978                 }
13979                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13980                 if (r->out.ctr == NULL) {
13981                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13982                 }
13983                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13984                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13985                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13986         }
13987         return NDR_ERR_SUCCESS;
13988 }
13989
13990 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships *r)
13991 {
13992         TALLOC_CTX *_mem_save_bind_handle_0;
13993         TALLOC_CTX *_mem_save_req_0;
13994         TALLOC_CTX *_mem_save_level_out_0;
13995         TALLOC_CTX *_mem_save_ctr_0;
13996         if (flags & NDR_IN) {
13997                 ZERO_STRUCT(r->out);
13998
13999                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14000                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14001                 }
14002                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14003                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14004                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14005                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14006                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14007                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14008                         NDR_PULL_ALLOC(ndr, r->in.req);
14009                 }
14010                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14011                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14012                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14013                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14014                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14015                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14016                 ZERO_STRUCTP(r->out.level_out);
14017                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14018                 ZERO_STRUCTP(r->out.ctr);
14019         }
14020         if (flags & NDR_OUT) {
14021                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14022                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14023                 }
14024                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14025                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14026                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14027                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14028                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14029                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14030                 }
14031                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14032                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14033                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14034                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14035                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14036                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14037         }
14038         return NDR_ERR_SUCCESS;
14039 }
14040
14041 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r)
14042 {
14043         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships");
14044         ndr->depth++;
14045         if (flags & NDR_SET_VALUES) {
14046                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14047         }
14048         if (flags & NDR_IN) {
14049                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships");
14050                 ndr->depth++;
14051                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14052                 ndr->depth++;
14053                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14054                 ndr->depth--;
14055                 ndr_print_int32(ndr, "level", r->in.level);
14056                 ndr_print_ptr(ndr, "req", r->in.req);
14057                 ndr->depth++;
14058                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14059                 ndr_print_drsuapi_DsGetMembershipsRequest(ndr, "req", r->in.req);
14060                 ndr->depth--;
14061                 ndr->depth--;
14062         }
14063         if (flags & NDR_OUT) {
14064                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships");
14065                 ndr->depth++;
14066                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14067                 ndr->depth++;
14068                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14069                 ndr->depth--;
14070                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14071                 ndr->depth++;
14072                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14073                 ndr_print_drsuapi_DsGetMembershipsCtr(ndr, "ctr", r->out.ctr);
14074                 ndr->depth--;
14075                 ndr_print_WERROR(ndr, "result", r->out.result);
14076                 ndr->depth--;
14077         }
14078         ndr->depth--;
14079 }
14080
14081 static enum ndr_err_code ndr_push_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_push *ndr, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14082 {
14083         if (flags & NDR_IN) {
14084         }
14085         if (flags & NDR_OUT) {
14086                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14087         }
14088         return NDR_ERR_SUCCESS;
14089 }
14090
14091 static enum ndr_err_code ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_pull *ndr, int flags, struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14092 {
14093         if (flags & NDR_IN) {
14094         }
14095         if (flags & NDR_OUT) {
14096                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14097         }
14098         return NDR_ERR_SUCCESS;
14099 }
14100
14101 _PUBLIC_ void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14102 {
14103         ndr_print_struct(ndr, name, "DRSUAPI_INTER_DOMAIN_MOVE");
14104         ndr->depth++;
14105         if (flags & NDR_SET_VALUES) {
14106                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14107         }
14108         if (flags & NDR_IN) {
14109                 ndr_print_struct(ndr, "in", "DRSUAPI_INTER_DOMAIN_MOVE");
14110                 ndr->depth++;
14111                 ndr->depth--;
14112         }
14113         if (flags & NDR_OUT) {
14114                 ndr_print_struct(ndr, "out", "DRSUAPI_INTER_DOMAIN_MOVE");
14115                 ndr->depth++;
14116                 ndr_print_WERROR(ndr, "result", r->out.result);
14117                 ndr->depth--;
14118         }
14119         ndr->depth--;
14120 }
14121
14122 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLog(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14123 {
14124         if (flags & NDR_IN) {
14125                 if (r->in.bind_handle == NULL) {
14126                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14127                 }
14128                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14129                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14130                 if (r->in.req == NULL) {
14131                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14132                 }
14133                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14134                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14135         }
14136         if (flags & NDR_OUT) {
14137                 if (r->out.level_out == NULL) {
14138                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14139                 }
14140                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14141                 if (r->out.info == NULL) {
14142                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14143                 }
14144                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.level_out));
14145                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14146                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14147         }
14148         return NDR_ERR_SUCCESS;
14149 }
14150
14151 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLog(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNT4ChangeLog *r)
14152 {
14153         TALLOC_CTX *_mem_save_bind_handle_0;
14154         TALLOC_CTX *_mem_save_req_0;
14155         TALLOC_CTX *_mem_save_level_out_0;
14156         TALLOC_CTX *_mem_save_info_0;
14157         if (flags & NDR_IN) {
14158                 ZERO_STRUCT(r->out);
14159
14160                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14161                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14162                 }
14163                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14164                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14165                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14166                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14168                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14169                         NDR_PULL_ALLOC(ndr, r->in.req);
14170                 }
14171                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14172                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14173                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14174                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14175                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14176                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14177                 ZERO_STRUCTP(r->out.level_out);
14178                 NDR_PULL_ALLOC(ndr, r->out.info);
14179                 ZERO_STRUCTP(r->out.info);
14180         }
14181         if (flags & NDR_OUT) {
14182                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14183                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14184                 }
14185                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14186                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14187                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14188                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14189                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14190                         NDR_PULL_ALLOC(ndr, r->out.info);
14191                 }
14192                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14193                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14194                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.level_out));
14195                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14196                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14197                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14198         }
14199         return NDR_ERR_SUCCESS;
14200 }
14201
14202 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLog(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14203 {
14204         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLog");
14205         ndr->depth++;
14206         if (flags & NDR_SET_VALUES) {
14207                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14208         }
14209         if (flags & NDR_IN) {
14210                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNT4ChangeLog");
14211                 ndr->depth++;
14212                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14213                 ndr->depth++;
14214                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14215                 ndr->depth--;
14216                 ndr_print_uint32(ndr, "level", r->in.level);
14217                 ndr_print_ptr(ndr, "req", r->in.req);
14218                 ndr->depth++;
14219                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14220                 ndr_print_drsuapi_DsGetNT4ChangeLogRequest(ndr, "req", r->in.req);
14221                 ndr->depth--;
14222                 ndr->depth--;
14223         }
14224         if (flags & NDR_OUT) {
14225                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNT4ChangeLog");
14226                 ndr->depth++;
14227                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14228                 ndr->depth++;
14229                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14230                 ndr->depth--;
14231                 ndr_print_ptr(ndr, "info", r->out.info);
14232                 ndr->depth++;
14233                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.level_out);
14234                 ndr_print_drsuapi_DsGetNT4ChangeLogInfo(ndr, "info", r->out.info);
14235                 ndr->depth--;
14236                 ndr_print_WERROR(ndr, "result", r->out.result);
14237                 ndr->depth--;
14238         }
14239         ndr->depth--;
14240 }
14241
14242 static enum ndr_err_code ndr_push_drsuapi_DsCrackNames(struct ndr_push *ndr, int flags, const struct drsuapi_DsCrackNames *r)
14243 {
14244         if (flags & NDR_IN) {
14245                 if (r->in.bind_handle == NULL) {
14246                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14247                 }
14248                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14249                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14250                 if (r->in.req == NULL) {
14251                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14252                 }
14253                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14254                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14255         }
14256         if (flags & NDR_OUT) {
14257                 if (r->out.level_out == NULL) {
14258                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14259                 }
14260                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14261                 if (r->out.ctr == NULL) {
14262                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14263                 }
14264                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14265                 NDR_CHECK(ndr_push_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14266                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14267         }
14268         return NDR_ERR_SUCCESS;
14269 }
14270
14271 static enum ndr_err_code ndr_pull_drsuapi_DsCrackNames(struct ndr_pull *ndr, int flags, struct drsuapi_DsCrackNames *r)
14272 {
14273         TALLOC_CTX *_mem_save_bind_handle_0;
14274         TALLOC_CTX *_mem_save_req_0;
14275         TALLOC_CTX *_mem_save_level_out_0;
14276         TALLOC_CTX *_mem_save_ctr_0;
14277         if (flags & NDR_IN) {
14278                 ZERO_STRUCT(r->out);
14279
14280                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14281                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14282                 }
14283                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14284                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14285                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14286                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14287                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14288                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14289                         NDR_PULL_ALLOC(ndr, r->in.req);
14290                 }
14291                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14292                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14293                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14294                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14295                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14296                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14297                 ZERO_STRUCTP(r->out.level_out);
14298                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14299                 ZERO_STRUCTP(r->out.ctr);
14300         }
14301         if (flags & NDR_OUT) {
14302                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14303                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14304                 }
14305                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14306                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14307                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14308                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14309                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14310                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14311                 }
14312                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14313                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14314                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14315                 NDR_CHECK(ndr_pull_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14316                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14317                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14318         }
14319         return NDR_ERR_SUCCESS;
14320 }
14321
14322 _PUBLIC_ void ndr_print_drsuapi_DsCrackNames(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsCrackNames *r)
14323 {
14324         ndr_print_struct(ndr, name, "drsuapi_DsCrackNames");
14325         ndr->depth++;
14326         if (flags & NDR_SET_VALUES) {
14327                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14328         }
14329         if (flags & NDR_IN) {
14330                 ndr_print_struct(ndr, "in", "drsuapi_DsCrackNames");
14331                 ndr->depth++;
14332                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14333                 ndr->depth++;
14334                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14335                 ndr->depth--;
14336                 ndr_print_int32(ndr, "level", r->in.level);
14337                 ndr_print_ptr(ndr, "req", r->in.req);
14338                 ndr->depth++;
14339                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14340                 ndr_print_drsuapi_DsNameRequest(ndr, "req", r->in.req);
14341                 ndr->depth--;
14342                 ndr->depth--;
14343         }
14344         if (flags & NDR_OUT) {
14345                 ndr_print_struct(ndr, "out", "drsuapi_DsCrackNames");
14346                 ndr->depth++;
14347                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14348                 ndr->depth++;
14349                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14350                 ndr->depth--;
14351                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14352                 ndr->depth++;
14353                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14354                 ndr_print_drsuapi_DsNameCtr(ndr, "ctr", r->out.ctr);
14355                 ndr->depth--;
14356                 ndr_print_WERROR(ndr, "result", r->out.result);
14357                 ndr->depth--;
14358         }
14359         ndr->depth--;
14360 }
14361
14362 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpn(struct ndr_push *ndr, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14363 {
14364         if (flags & NDR_IN) {
14365                 if (r->in.bind_handle == NULL) {
14366                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14367                 }
14368                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14369                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14370                 if (r->in.req == NULL) {
14371                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14372                 }
14373                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14374                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14375         }
14376         if (flags & NDR_OUT) {
14377                 if (r->out.level_out == NULL) {
14378                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14379                 }
14380                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14381                 if (r->out.res == NULL) {
14382                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14383                 }
14384                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14385                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14386                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14387         }
14388         return NDR_ERR_SUCCESS;
14389 }
14390
14391 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpn(struct ndr_pull *ndr, int flags, struct drsuapi_DsWriteAccountSpn *r)
14392 {
14393         TALLOC_CTX *_mem_save_bind_handle_0;
14394         TALLOC_CTX *_mem_save_req_0;
14395         TALLOC_CTX *_mem_save_level_out_0;
14396         TALLOC_CTX *_mem_save_res_0;
14397         if (flags & NDR_IN) {
14398                 ZERO_STRUCT(r->out);
14399
14400                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14401                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14402                 }
14403                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14404                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14405                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14406                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14407                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14408                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14409                         NDR_PULL_ALLOC(ndr, r->in.req);
14410                 }
14411                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14412                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14413                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14414                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14415                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14416                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14417                 ZERO_STRUCTP(r->out.level_out);
14418                 NDR_PULL_ALLOC(ndr, r->out.res);
14419                 ZERO_STRUCTP(r->out.res);
14420         }
14421         if (flags & NDR_OUT) {
14422                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14423                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14424                 }
14425                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14426                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14427                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14428                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14429                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14430                         NDR_PULL_ALLOC(ndr, r->out.res);
14431                 }
14432                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14433                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14434                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14435                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14436                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14437                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14438         }
14439         return NDR_ERR_SUCCESS;
14440 }
14441
14442 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpn(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14443 {
14444         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpn");
14445         ndr->depth++;
14446         if (flags & NDR_SET_VALUES) {
14447                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14448         }
14449         if (flags & NDR_IN) {
14450                 ndr_print_struct(ndr, "in", "drsuapi_DsWriteAccountSpn");
14451                 ndr->depth++;
14452                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14453                 ndr->depth++;
14454                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14455                 ndr->depth--;
14456                 ndr_print_int32(ndr, "level", r->in.level);
14457                 ndr_print_ptr(ndr, "req", r->in.req);
14458                 ndr->depth++;
14459                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14460                 ndr_print_drsuapi_DsWriteAccountSpnRequest(ndr, "req", r->in.req);
14461                 ndr->depth--;
14462                 ndr->depth--;
14463         }
14464         if (flags & NDR_OUT) {
14465                 ndr_print_struct(ndr, "out", "drsuapi_DsWriteAccountSpn");
14466                 ndr->depth++;
14467                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14468                 ndr->depth++;
14469                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14470                 ndr->depth--;
14471                 ndr_print_ptr(ndr, "res", r->out.res);
14472                 ndr->depth++;
14473                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14474                 ndr_print_drsuapi_DsWriteAccountSpnResult(ndr, "res", r->out.res);
14475                 ndr->depth--;
14476                 ndr_print_WERROR(ndr, "result", r->out.result);
14477                 ndr->depth--;
14478         }
14479         ndr->depth--;
14480 }
14481
14482 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServer(struct ndr_push *ndr, int flags, const struct drsuapi_DsRemoveDSServer *r)
14483 {
14484         if (flags & NDR_IN) {
14485                 if (r->in.bind_handle == NULL) {
14486                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14487                 }
14488                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14489                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14490                 if (r->in.req == NULL) {
14491                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14492                 }
14493                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14494                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14495         }
14496         if (flags & NDR_OUT) {
14497                 if (r->out.level_out == NULL) {
14498                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14499                 }
14500                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14501                 if (r->out.res == NULL) {
14502                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14503                 }
14504                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14505                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14506                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14507         }
14508         return NDR_ERR_SUCCESS;
14509 }
14510
14511 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServer(struct ndr_pull *ndr, int flags, struct drsuapi_DsRemoveDSServer *r)
14512 {
14513         TALLOC_CTX *_mem_save_bind_handle_0;
14514         TALLOC_CTX *_mem_save_req_0;
14515         TALLOC_CTX *_mem_save_level_out_0;
14516         TALLOC_CTX *_mem_save_res_0;
14517         if (flags & NDR_IN) {
14518                 ZERO_STRUCT(r->out);
14519
14520                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14521                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14522                 }
14523                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14524                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14525                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14526                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14527                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14528                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14529                         NDR_PULL_ALLOC(ndr, r->in.req);
14530                 }
14531                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14532                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14533                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14534                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14535                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14536                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14537                 ZERO_STRUCTP(r->out.level_out);
14538                 NDR_PULL_ALLOC(ndr, r->out.res);
14539                 ZERO_STRUCTP(r->out.res);
14540         }
14541         if (flags & NDR_OUT) {
14542                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14543                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14544                 }
14545                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14546                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14547                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14548                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14549                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14550                         NDR_PULL_ALLOC(ndr, r->out.res);
14551                 }
14552                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14553                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14554                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14555                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14556                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14557                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14558         }
14559         return NDR_ERR_SUCCESS;
14560 }
14561
14562 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServer(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsRemoveDSServer *r)
14563 {
14564         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServer");
14565         ndr->depth++;
14566         if (flags & NDR_SET_VALUES) {
14567                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14568         }
14569         if (flags & NDR_IN) {
14570                 ndr_print_struct(ndr, "in", "drsuapi_DsRemoveDSServer");
14571                 ndr->depth++;
14572                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14573                 ndr->depth++;
14574                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14575                 ndr->depth--;
14576                 ndr_print_int32(ndr, "level", r->in.level);
14577                 ndr_print_ptr(ndr, "req", r->in.req);
14578                 ndr->depth++;
14579                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14580                 ndr_print_drsuapi_DsRemoveDSServerRequest(ndr, "req", r->in.req);
14581                 ndr->depth--;
14582                 ndr->depth--;
14583         }
14584         if (flags & NDR_OUT) {
14585                 ndr_print_struct(ndr, "out", "drsuapi_DsRemoveDSServer");
14586                 ndr->depth++;
14587                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14588                 ndr->depth++;
14589                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14590                 ndr->depth--;
14591                 ndr_print_ptr(ndr, "res", r->out.res);
14592                 ndr->depth++;
14593                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14594                 ndr_print_drsuapi_DsRemoveDSServerResult(ndr, "res", r->out.res);
14595                 ndr->depth--;
14596                 ndr_print_WERROR(ndr, "result", r->out.result);
14597                 ndr->depth--;
14598         }
14599         ndr->depth--;
14600 }
14601
14602 static enum ndr_err_code ndr_push_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_push *ndr, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14603 {
14604         if (flags & NDR_IN) {
14605         }
14606         if (flags & NDR_OUT) {
14607                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14608         }
14609         return NDR_ERR_SUCCESS;
14610 }
14611
14612 static enum ndr_err_code ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_pull *ndr, int flags, struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14613 {
14614         if (flags & NDR_IN) {
14615         }
14616         if (flags & NDR_OUT) {
14617                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14618         }
14619         return NDR_ERR_SUCCESS;
14620 }
14621
14622 _PUBLIC_ void ndr_print_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14623 {
14624         ndr_print_struct(ndr, name, "DRSUAPI_REMOVE_DS_DOMAIN");
14625         ndr->depth++;
14626         if (flags & NDR_SET_VALUES) {
14627                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14628         }
14629         if (flags & NDR_IN) {
14630                 ndr_print_struct(ndr, "in", "DRSUAPI_REMOVE_DS_DOMAIN");
14631                 ndr->depth++;
14632                 ndr->depth--;
14633         }
14634         if (flags & NDR_OUT) {
14635                 ndr_print_struct(ndr, "out", "DRSUAPI_REMOVE_DS_DOMAIN");
14636                 ndr->depth++;
14637                 ndr_print_WERROR(ndr, "result", r->out.result);
14638                 ndr->depth--;
14639         }
14640         ndr->depth--;
14641 }
14642
14643 static enum ndr_err_code ndr_push_drsuapi_DsGetDomainControllerInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14644 {
14645         if (flags & NDR_IN) {
14646                 if (r->in.bind_handle == NULL) {
14647                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14648                 }
14649                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14650                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14651                 if (r->in.req == NULL) {
14652                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14653                 }
14654                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14655                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14656         }
14657         if (flags & NDR_OUT) {
14658                 if (r->out.level_out == NULL) {
14659                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14660                 }
14661                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14662                 if (r->out.ctr == NULL) {
14663                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14664                 }
14665                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14666                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14667                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14668         }
14669         return NDR_ERR_SUCCESS;
14670 }
14671
14672 static enum ndr_err_code ndr_pull_drsuapi_DsGetDomainControllerInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetDomainControllerInfo *r)
14673 {
14674         TALLOC_CTX *_mem_save_bind_handle_0;
14675         TALLOC_CTX *_mem_save_req_0;
14676         TALLOC_CTX *_mem_save_level_out_0;
14677         TALLOC_CTX *_mem_save_ctr_0;
14678         if (flags & NDR_IN) {
14679                 ZERO_STRUCT(r->out);
14680
14681                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14682                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14683                 }
14684                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14685                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14686                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14687                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14688                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14689                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14690                         NDR_PULL_ALLOC(ndr, r->in.req);
14691                 }
14692                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14693                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14694                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14695                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14696                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14697                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14698                 ZERO_STRUCTP(r->out.level_out);
14699                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14700                 ZERO_STRUCTP(r->out.ctr);
14701         }
14702         if (flags & NDR_OUT) {
14703                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14704                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14705                 }
14706                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14707                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14708                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14709                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14710                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14711                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14712                 }
14713                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14714                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14715                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14716                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14717                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14718                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14719         }
14720         return NDR_ERR_SUCCESS;
14721 }
14722
14723 _PUBLIC_ void ndr_print_drsuapi_DsGetDomainControllerInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14724 {
14725         ndr_print_struct(ndr, name, "drsuapi_DsGetDomainControllerInfo");
14726         ndr->depth++;
14727         if (flags & NDR_SET_VALUES) {
14728                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14729         }
14730         if (flags & NDR_IN) {
14731                 ndr_print_struct(ndr, "in", "drsuapi_DsGetDomainControllerInfo");
14732                 ndr->depth++;
14733                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14734                 ndr->depth++;
14735                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14736                 ndr->depth--;
14737                 ndr_print_int32(ndr, "level", r->in.level);
14738                 ndr_print_ptr(ndr, "req", r->in.req);
14739                 ndr->depth++;
14740                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14741                 ndr_print_drsuapi_DsGetDCInfoRequest(ndr, "req", r->in.req);
14742                 ndr->depth--;
14743                 ndr->depth--;
14744         }
14745         if (flags & NDR_OUT) {
14746                 ndr_print_struct(ndr, "out", "drsuapi_DsGetDomainControllerInfo");
14747                 ndr->depth++;
14748                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14749                 ndr->depth++;
14750                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14751                 ndr->depth--;
14752                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14753                 ndr->depth++;
14754                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14755                 ndr_print_drsuapi_DsGetDCInfoCtr(ndr, "ctr", r->out.ctr);
14756                 ndr->depth--;
14757                 ndr_print_WERROR(ndr, "result", r->out.result);
14758                 ndr->depth--;
14759         }
14760         ndr->depth--;
14761 }
14762
14763 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAddEntry(struct ndr_push *ndr, int flags, const struct drsuapi_DsAddEntry *r)
14764 {
14765         if (flags & NDR_IN) {
14766                 if (r->in.bind_handle == NULL) {
14767                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14768                 }
14769                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14770                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14771                 if (r->in.req == NULL) {
14772                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14773                 }
14774                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14775                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14776         }
14777         if (flags & NDR_OUT) {
14778                 if (r->out.level_out == NULL) {
14779                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14780                 }
14781                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14782                 if (r->out.ctr == NULL) {
14783                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14784                 }
14785                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14786                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14787                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14788         }
14789         return NDR_ERR_SUCCESS;
14790 }
14791
14792 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAddEntry(struct ndr_pull *ndr, int flags, struct drsuapi_DsAddEntry *r)
14793 {
14794         TALLOC_CTX *_mem_save_bind_handle_0;
14795         TALLOC_CTX *_mem_save_req_0;
14796         TALLOC_CTX *_mem_save_level_out_0;
14797         TALLOC_CTX *_mem_save_ctr_0;
14798         if (flags & NDR_IN) {
14799                 ZERO_STRUCT(r->out);
14800
14801                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14802                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14803                 }
14804                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14805                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14806                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14807                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14808                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14809                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14810                         NDR_PULL_ALLOC(ndr, r->in.req);
14811                 }
14812                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14813                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14814                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14815                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14816                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14817                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14818                 ZERO_STRUCTP(r->out.level_out);
14819                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14820                 ZERO_STRUCTP(r->out.ctr);
14821         }
14822         if (flags & NDR_OUT) {
14823                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14824                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14825                 }
14826                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14827                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14828                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14829                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14830                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14831                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14832                 }
14833                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14834                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14835                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14836                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14837                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14838                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14839         }
14840         return NDR_ERR_SUCCESS;
14841 }
14842
14843 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsAddEntry *r)
14844 {
14845         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry");
14846         ndr->depth++;
14847         if (flags & NDR_SET_VALUES) {
14848                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14849         }
14850         if (flags & NDR_IN) {
14851                 ndr_print_struct(ndr, "in", "drsuapi_DsAddEntry");
14852                 ndr->depth++;
14853                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14854                 ndr->depth++;
14855                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14856                 ndr->depth--;
14857                 ndr_print_int32(ndr, "level", r->in.level);
14858                 ndr_print_ptr(ndr, "req", r->in.req);
14859                 ndr->depth++;
14860                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14861                 ndr_print_drsuapi_DsAddEntryRequest(ndr, "req", r->in.req);
14862                 ndr->depth--;
14863                 ndr->depth--;
14864         }
14865         if (flags & NDR_OUT) {
14866                 ndr_print_struct(ndr, "out", "drsuapi_DsAddEntry");
14867                 ndr->depth++;
14868                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14869                 ndr->depth++;
14870                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14871                 ndr->depth--;
14872                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14873                 ndr->depth++;
14874                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14875                 ndr_print_drsuapi_DsAddEntryCtr(ndr, "ctr", r->out.ctr);
14876                 ndr->depth--;
14877                 ndr_print_WERROR(ndr, "result", r->out.result);
14878                 ndr->depth--;
14879         }
14880         ndr->depth--;
14881 }
14882
14883 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC(struct ndr_push *ndr, int flags, const struct drsuapi_DsExecuteKCC *r)
14884 {
14885         if (flags & NDR_IN) {
14886                 if (r->in.bind_handle == NULL) {
14887                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14888                 }
14889                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14891                 if (r->in.req == NULL) {
14892                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14893                 }
14894                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14895                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14896         }
14897         if (flags & NDR_OUT) {
14898                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14899         }
14900         return NDR_ERR_SUCCESS;
14901 }
14902
14903 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC(struct ndr_pull *ndr, int flags, struct drsuapi_DsExecuteKCC *r)
14904 {
14905         TALLOC_CTX *_mem_save_bind_handle_0;
14906         TALLOC_CTX *_mem_save_req_0;
14907         if (flags & NDR_IN) {
14908                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14909                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14910                 }
14911                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14912                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14913                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14914                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14916                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14917                         NDR_PULL_ALLOC(ndr, r->in.req);
14918                 }
14919                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14920                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14921                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14922                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14923                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14924         }
14925         if (flags & NDR_OUT) {
14926                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14927         }
14928         return NDR_ERR_SUCCESS;
14929 }
14930
14931 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsExecuteKCC *r)
14932 {
14933         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC");
14934         ndr->depth++;
14935         if (flags & NDR_SET_VALUES) {
14936                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14937         }
14938         if (flags & NDR_IN) {
14939                 ndr_print_struct(ndr, "in", "drsuapi_DsExecuteKCC");
14940                 ndr->depth++;
14941                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14942                 ndr->depth++;
14943                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14944                 ndr->depth--;
14945                 ndr_print_uint32(ndr, "level", r->in.level);
14946                 ndr_print_ptr(ndr, "req", r->in.req);
14947                 ndr->depth++;
14948                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14949                 ndr_print_drsuapi_DsExecuteKCCRequest(ndr, "req", r->in.req);
14950                 ndr->depth--;
14951                 ndr->depth--;
14952         }
14953         if (flags & NDR_OUT) {
14954                 ndr_print_struct(ndr, "out", "drsuapi_DsExecuteKCC");
14955                 ndr->depth++;
14956                 ndr_print_WERROR(ndr, "result", r->out.result);
14957                 ndr->depth--;
14958         }
14959         ndr->depth--;
14960 }
14961
14962 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaGetInfo *r)
14963 {
14964         if (flags & NDR_IN) {
14965                 if (r->in.bind_handle == NULL) {
14966                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14967                 }
14968                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14969                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, r->in.level));
14970                 if (r->in.req == NULL) {
14971                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14972                 }
14973                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14974                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14975         }
14976         if (flags & NDR_OUT) {
14977                 if (r->out.info_type == NULL) {
14978                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14979                 }
14980                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, *r->out.info_type));
14981                 if (r->out.info == NULL) {
14982                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14983                 }
14984                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.info_type));
14985                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14986                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14987         }
14988         return NDR_ERR_SUCCESS;
14989 }
14990
14991 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaGetInfo *r)
14992 {
14993         TALLOC_CTX *_mem_save_bind_handle_0;
14994         TALLOC_CTX *_mem_save_req_0;
14995         TALLOC_CTX *_mem_save_info_type_0;
14996         TALLOC_CTX *_mem_save_info_0;
14997         if (flags & NDR_IN) {
14998                 ZERO_STRUCT(r->out);
14999
15000                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15001                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15002                 }
15003                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15004                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15005                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15006                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15007                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, &r->in.level));
15008                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15009                         NDR_PULL_ALLOC(ndr, r->in.req);
15010                 }
15011                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15012                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15013                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15014                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15015                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15016                 NDR_PULL_ALLOC(ndr, r->out.info_type);
15017                 ZERO_STRUCTP(r->out.info_type);
15018                 NDR_PULL_ALLOC(ndr, r->out.info);
15019                 ZERO_STRUCTP(r->out.info);
15020         }
15021         if (flags & NDR_OUT) {
15022                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15023                         NDR_PULL_ALLOC(ndr, r->out.info_type);
15024                 }
15025                 _mem_save_info_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
15026                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_type, LIBNDR_FLAG_REF_ALLOC);
15027                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->out.info_type));
15028                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_type_0, LIBNDR_FLAG_REF_ALLOC);
15029                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15030                         NDR_PULL_ALLOC(ndr, r->out.info);
15031                 }
15032                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15033                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
15034                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.info_type));
15035                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15036                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15037                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15038         }
15039         return NDR_ERR_SUCCESS;
15040 }
15041
15042 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaGetInfo *r)
15043 {
15044         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfo");
15045         ndr->depth++;
15046         if (flags & NDR_SET_VALUES) {
15047                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15048         }
15049         if (flags & NDR_IN) {
15050                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaGetInfo");
15051                 ndr->depth++;
15052                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15053                 ndr->depth++;
15054                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15055                 ndr->depth--;
15056                 ndr_print_drsuapi_DsReplicaGetInfoLevel(ndr, "level", r->in.level);
15057                 ndr_print_ptr(ndr, "req", r->in.req);
15058                 ndr->depth++;
15059                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15060                 ndr_print_drsuapi_DsReplicaGetInfoRequest(ndr, "req", r->in.req);
15061                 ndr->depth--;
15062                 ndr->depth--;
15063         }
15064         if (flags & NDR_OUT) {
15065                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaGetInfo");
15066                 ndr->depth++;
15067                 ndr_print_ptr(ndr, "info_type", r->out.info_type);
15068                 ndr->depth++;
15069                 ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", *r->out.info_type);
15070                 ndr->depth--;
15071                 ndr_print_ptr(ndr, "info", r->out.info);
15072                 ndr->depth++;
15073                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.info_type);
15074                 ndr_print_drsuapi_DsReplicaInfo(ndr, "info", r->out.info);
15075                 ndr->depth--;
15076                 ndr_print_WERROR(ndr, "result", r->out.result);
15077                 ndr->depth--;
15078         }
15079         ndr->depth--;
15080 }
15081
15082 static enum ndr_err_code ndr_push_DRSUAPI_ADD_SID_HISTORY(struct ndr_push *ndr, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15083 {
15084         if (flags & NDR_IN) {
15085         }
15086         if (flags & NDR_OUT) {
15087                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15088         }
15089         return NDR_ERR_SUCCESS;
15090 }
15091
15092 static enum ndr_err_code ndr_pull_DRSUAPI_ADD_SID_HISTORY(struct ndr_pull *ndr, int flags, struct DRSUAPI_ADD_SID_HISTORY *r)
15093 {
15094         if (flags & NDR_IN) {
15095         }
15096         if (flags & NDR_OUT) {
15097                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15098         }
15099         return NDR_ERR_SUCCESS;
15100 }
15101
15102 _PUBLIC_ void ndr_print_DRSUAPI_ADD_SID_HISTORY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15103 {
15104         ndr_print_struct(ndr, name, "DRSUAPI_ADD_SID_HISTORY");
15105         ndr->depth++;
15106         if (flags & NDR_SET_VALUES) {
15107                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15108         }
15109         if (flags & NDR_IN) {
15110                 ndr_print_struct(ndr, "in", "DRSUAPI_ADD_SID_HISTORY");
15111                 ndr->depth++;
15112                 ndr->depth--;
15113         }
15114         if (flags & NDR_OUT) {
15115                 ndr_print_struct(ndr, "out", "DRSUAPI_ADD_SID_HISTORY");
15116                 ndr->depth++;
15117                 ndr_print_WERROR(ndr, "result", r->out.result);
15118                 ndr->depth--;
15119         }
15120         ndr->depth--;
15121 }
15122
15123 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships2 *r)
15124 {
15125         if (flags & NDR_IN) {
15126                 if (r->in.bind_handle == NULL) {
15127                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15128                 }
15129                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15130                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15131                 if (r->in.req == NULL) {
15132                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15133                 }
15134                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15135                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15136         }
15137         if (flags & NDR_OUT) {
15138                 if (r->out.level_out == NULL) {
15139                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15140                 }
15141                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15142                 if (r->out.ctr == NULL) {
15143                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15144                 }
15145                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15146                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15147                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15148         }
15149         return NDR_ERR_SUCCESS;
15150 }
15151
15152 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships2 *r)
15153 {
15154         TALLOC_CTX *_mem_save_bind_handle_0;
15155         TALLOC_CTX *_mem_save_req_0;
15156         TALLOC_CTX *_mem_save_level_out_0;
15157         TALLOC_CTX *_mem_save_ctr_0;
15158         if (flags & NDR_IN) {
15159                 ZERO_STRUCT(r->out);
15160
15161                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15162                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15163                 }
15164                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15165                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15166                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15167                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15168                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15169                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15170                         NDR_PULL_ALLOC(ndr, r->in.req);
15171                 }
15172                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15173                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15174                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15175                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15176                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15177                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15178                 ZERO_STRUCTP(r->out.level_out);
15179                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15180                 ZERO_STRUCTP(r->out.ctr);
15181         }
15182         if (flags & NDR_OUT) {
15183                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15184                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15185                 }
15186                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15187                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15188                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15189                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15190                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15191                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15192                 }
15193                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15194                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15195                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15196                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15197                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15198                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15199         }
15200         return NDR_ERR_SUCCESS;
15201 }
15202
15203 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships2 *r)
15204 {
15205         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2");
15206         ndr->depth++;
15207         if (flags & NDR_SET_VALUES) {
15208                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15209         }
15210         if (flags & NDR_IN) {
15211                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships2");
15212                 ndr->depth++;
15213                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15214                 ndr->depth++;
15215                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15216                 ndr->depth--;
15217                 ndr_print_int32(ndr, "level", r->in.level);
15218                 ndr_print_ptr(ndr, "req", r->in.req);
15219                 ndr->depth++;
15220                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15221                 ndr_print_drsuapi_DsGetMemberships2Request(ndr, "req", r->in.req);
15222                 ndr->depth--;
15223                 ndr->depth--;
15224         }
15225         if (flags & NDR_OUT) {
15226                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships2");
15227                 ndr->depth++;
15228                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15229                 ndr->depth++;
15230                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15231                 ndr->depth--;
15232                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15233                 ndr->depth++;
15234                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15235                 ndr_print_drsuapi_DsGetMemberships2Ctr(ndr, "ctr", r->out.ctr);
15236                 ndr->depth--;
15237                 ndr_print_WERROR(ndr, "result", r->out.result);
15238                 ndr->depth--;
15239         }
15240         ndr->depth--;
15241 }
15242
15243 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15244 {
15245         if (flags & NDR_IN) {
15246         }
15247         if (flags & NDR_OUT) {
15248                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15249         }
15250         return NDR_ERR_SUCCESS;
15251 }
15252
15253 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15254 {
15255         if (flags & NDR_IN) {
15256         }
15257         if (flags & NDR_OUT) {
15258                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15259         }
15260         return NDR_ERR_SUCCESS;
15261 }
15262
15263 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15264 {
15265         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15266         ndr->depth++;
15267         if (flags & NDR_SET_VALUES) {
15268                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15269         }
15270         if (flags & NDR_IN) {
15271                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15272                 ndr->depth++;
15273                 ndr->depth--;
15274         }
15275         if (flags & NDR_OUT) {
15276                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15277                 ndr->depth++;
15278                 ndr_print_WERROR(ndr, "result", r->out.result);
15279                 ndr->depth--;
15280         }
15281         ndr->depth--;
15282 }
15283
15284 static enum ndr_err_code ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_push *ndr, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15285 {
15286         if (flags & NDR_IN) {
15287         }
15288         if (flags & NDR_OUT) {
15289                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15290         }
15291         return NDR_ERR_SUCCESS;
15292 }
15293
15294 static enum ndr_err_code ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_pull *ndr, int flags, struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15295 {
15296         if (flags & NDR_IN) {
15297         }
15298         if (flags & NDR_OUT) {
15299                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15300         }
15301         return NDR_ERR_SUCCESS;
15302 }
15303
15304 _PUBLIC_ void ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15305 {
15306         ndr_print_struct(ndr, name, "DRSUAPI_GET_OBJECT_EXISTENCE");
15307         ndr->depth++;
15308         if (flags & NDR_SET_VALUES) {
15309                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15310         }
15311         if (flags & NDR_IN) {
15312                 ndr_print_struct(ndr, "in", "DRSUAPI_GET_OBJECT_EXISTENCE");
15313                 ndr->depth++;
15314                 ndr->depth--;
15315         }
15316         if (flags & NDR_OUT) {
15317                 ndr_print_struct(ndr, "out", "DRSUAPI_GET_OBJECT_EXISTENCE");
15318                 ndr->depth++;
15319                 ndr_print_WERROR(ndr, "result", r->out.result);
15320                 ndr->depth--;
15321         }
15322         ndr->depth--;
15323 }
15324
15325 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCost(struct ndr_push *ndr, int flags, const struct drsuapi_QuerySitesByCost *r)
15326 {
15327         if (flags & NDR_IN) {
15328                 if (r->in.bind_handle == NULL) {
15329                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15330                 }
15331                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15332                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15333                 if (r->in.req == NULL) {
15334                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15335                 }
15336                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15337                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15338         }
15339         if (flags & NDR_OUT) {
15340                 if (r->out.level_out == NULL) {
15341                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15342                 }
15343                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15344                 if (r->out.ctr == NULL) {
15345                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15346                 }
15347                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15348                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15349                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15350         }
15351         return NDR_ERR_SUCCESS;
15352 }
15353
15354 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCost(struct ndr_pull *ndr, int flags, struct drsuapi_QuerySitesByCost *r)
15355 {
15356         TALLOC_CTX *_mem_save_bind_handle_0;
15357         TALLOC_CTX *_mem_save_req_0;
15358         TALLOC_CTX *_mem_save_level_out_0;
15359         TALLOC_CTX *_mem_save_ctr_0;
15360         if (flags & NDR_IN) {
15361                 ZERO_STRUCT(r->out);
15362
15363                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15364                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15365                 }
15366                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15367                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15368                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15369                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15370                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15371                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15372                         NDR_PULL_ALLOC(ndr, r->in.req);
15373                 }
15374                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15375                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15376                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15377                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15378                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15379                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15380                 ZERO_STRUCTP(r->out.level_out);
15381                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15382                 ZERO_STRUCTP(r->out.ctr);
15383         }
15384         if (flags & NDR_OUT) {
15385                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15386                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15387                 }
15388                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15389                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15390                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15391                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15392                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15393                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15394                 }
15395                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15396                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15397                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15398                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15399                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15400                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15401         }
15402         return NDR_ERR_SUCCESS;
15403 }
15404
15405 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCost(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_QuerySitesByCost *r)
15406 {
15407         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCost");
15408         ndr->depth++;
15409         if (flags & NDR_SET_VALUES) {
15410                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15411         }
15412         if (flags & NDR_IN) {
15413                 ndr_print_struct(ndr, "in", "drsuapi_QuerySitesByCost");
15414                 ndr->depth++;
15415                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15416                 ndr->depth++;
15417                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15418                 ndr->depth--;
15419                 ndr_print_int32(ndr, "level", r->in.level);
15420                 ndr_print_ptr(ndr, "req", r->in.req);
15421                 ndr->depth++;
15422                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15423                 ndr_print_drsuapi_QuerySitesByCostRequest(ndr, "req", r->in.req);
15424                 ndr->depth--;
15425                 ndr->depth--;
15426         }
15427         if (flags & NDR_OUT) {
15428                 ndr_print_struct(ndr, "out", "drsuapi_QuerySitesByCost");
15429                 ndr->depth++;
15430                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15431                 ndr->depth++;
15432                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15433                 ndr->depth--;
15434                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15435                 ndr->depth++;
15436                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15437                 ndr_print_drsuapi_QuerySitesByCostCtr(ndr, "ctr", r->out.ctr);
15438                 ndr->depth--;
15439                 ndr_print_WERROR(ndr, "result", r->out.result);
15440                 ndr->depth--;
15441         }
15442         ndr->depth--;
15443 }
15444
15445 static const struct ndr_interface_call drsuapi_calls[] = {
15446         {
15447                 "drsuapi_DsBind",
15448                 sizeof(struct drsuapi_DsBind),
15449                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsBind,
15450                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsBind,
15451                 (ndr_print_function_t) ndr_print_drsuapi_DsBind,
15452                 false,
15453         },
15454         {
15455                 "drsuapi_DsUnbind",
15456                 sizeof(struct drsuapi_DsUnbind),
15457                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsUnbind,
15458                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsUnbind,
15459                 (ndr_print_function_t) ndr_print_drsuapi_DsUnbind,
15460                 false,
15461         },
15462         {
15463                 "drsuapi_DsReplicaSync",
15464                 sizeof(struct drsuapi_DsReplicaSync),
15465                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaSync,
15466                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaSync,
15467                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaSync,
15468                 false,
15469         },
15470         {
15471                 "drsuapi_DsGetNCChanges",
15472                 sizeof(struct drsuapi_DsGetNCChanges),
15473                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNCChanges,
15474                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNCChanges,
15475                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNCChanges,
15476                 false,
15477         },
15478         {
15479                 "drsuapi_DsReplicaUpdateRefs",
15480                 sizeof(struct drsuapi_DsReplicaUpdateRefs),
15481                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaUpdateRefs,
15482                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaUpdateRefs,
15483                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaUpdateRefs,
15484                 false,
15485         },
15486         {
15487                 "drsuapi_DsReplicaAdd",
15488                 sizeof(struct drsuapi_DsReplicaAdd),
15489                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaAdd,
15490                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaAdd,
15491                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaAdd,
15492                 false,
15493         },
15494         {
15495                 "drsuapi_DsReplicaDel",
15496                 sizeof(struct drsuapi_DsReplicaDel),
15497                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaDel,
15498                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaDel,
15499                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaDel,
15500                 false,
15501         },
15502         {
15503                 "drsuapi_DsReplicaMod",
15504                 sizeof(struct drsuapi_DsReplicaMod),
15505                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaMod,
15506                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaMod,
15507                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaMod,
15508                 false,
15509         },
15510         {
15511                 "DRSUAPI_VERIFY_NAMES",
15512                 sizeof(struct DRSUAPI_VERIFY_NAMES),
15513                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_VERIFY_NAMES,
15514                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_VERIFY_NAMES,
15515                 (ndr_print_function_t) ndr_print_DRSUAPI_VERIFY_NAMES,
15516                 false,
15517         },
15518         {
15519                 "drsuapi_DsGetMemberships",
15520                 sizeof(struct drsuapi_DsGetMemberships),
15521                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships,
15522                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships,
15523                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships,
15524                 false,
15525         },
15526         {
15527                 "DRSUAPI_INTER_DOMAIN_MOVE",
15528                 sizeof(struct DRSUAPI_INTER_DOMAIN_MOVE),
15529                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_INTER_DOMAIN_MOVE,
15530                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE,
15531                 (ndr_print_function_t) ndr_print_DRSUAPI_INTER_DOMAIN_MOVE,
15532                 false,
15533         },
15534         {
15535                 "drsuapi_DsGetNT4ChangeLog",
15536                 sizeof(struct drsuapi_DsGetNT4ChangeLog),
15537                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNT4ChangeLog,
15538                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNT4ChangeLog,
15539                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNT4ChangeLog,
15540                 false,
15541         },
15542         {
15543                 "drsuapi_DsCrackNames",
15544                 sizeof(struct drsuapi_DsCrackNames),
15545                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsCrackNames,
15546                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsCrackNames,
15547                 (ndr_print_function_t) ndr_print_drsuapi_DsCrackNames,
15548                 false,
15549         },
15550         {
15551                 "drsuapi_DsWriteAccountSpn",
15552                 sizeof(struct drsuapi_DsWriteAccountSpn),
15553                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsWriteAccountSpn,
15554                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsWriteAccountSpn,
15555                 (ndr_print_function_t) ndr_print_drsuapi_DsWriteAccountSpn,
15556                 false,
15557         },
15558         {
15559                 "drsuapi_DsRemoveDSServer",
15560                 sizeof(struct drsuapi_DsRemoveDSServer),
15561                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsRemoveDSServer,
15562                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsRemoveDSServer,
15563                 (ndr_print_function_t) ndr_print_drsuapi_DsRemoveDSServer,
15564                 false,
15565         },
15566         {
15567                 "DRSUAPI_REMOVE_DS_DOMAIN",
15568                 sizeof(struct DRSUAPI_REMOVE_DS_DOMAIN),
15569                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REMOVE_DS_DOMAIN,
15570                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN,
15571                 (ndr_print_function_t) ndr_print_DRSUAPI_REMOVE_DS_DOMAIN,
15572                 false,
15573         },
15574         {
15575                 "drsuapi_DsGetDomainControllerInfo",
15576                 sizeof(struct drsuapi_DsGetDomainControllerInfo),
15577                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetDomainControllerInfo,
15578                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetDomainControllerInfo,
15579                 (ndr_print_function_t) ndr_print_drsuapi_DsGetDomainControllerInfo,
15580                 false,
15581         },
15582         {
15583                 "drsuapi_DsAddEntry",
15584                 sizeof(struct drsuapi_DsAddEntry),
15585                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsAddEntry,
15586                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsAddEntry,
15587                 (ndr_print_function_t) ndr_print_drsuapi_DsAddEntry,
15588                 false,
15589         },
15590         {
15591                 "drsuapi_DsExecuteKCC",
15592                 sizeof(struct drsuapi_DsExecuteKCC),
15593                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsExecuteKCC,
15594                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsExecuteKCC,
15595                 (ndr_print_function_t) ndr_print_drsuapi_DsExecuteKCC,
15596                 false,
15597         },
15598         {
15599                 "drsuapi_DsReplicaGetInfo",
15600                 sizeof(struct drsuapi_DsReplicaGetInfo),
15601                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaGetInfo,
15602                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaGetInfo,
15603                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaGetInfo,
15604                 false,
15605         },
15606         {
15607                 "DRSUAPI_ADD_SID_HISTORY",
15608                 sizeof(struct DRSUAPI_ADD_SID_HISTORY),
15609                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_ADD_SID_HISTORY,
15610                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_ADD_SID_HISTORY,
15611                 (ndr_print_function_t) ndr_print_DRSUAPI_ADD_SID_HISTORY,
15612                 false,
15613         },
15614         {
15615                 "drsuapi_DsGetMemberships2",
15616                 sizeof(struct drsuapi_DsGetMemberships2),
15617                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships2,
15618                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships2,
15619                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships2,
15620                 false,
15621         },
15622         {
15623                 "DRSUAPI_REPLICA_VERIFY_OBJECTS",
15624                 sizeof(struct DRSUAPI_REPLICA_VERIFY_OBJECTS),
15625                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15626                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15627                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15628                 false,
15629         },
15630         {
15631                 "DRSUAPI_GET_OBJECT_EXISTENCE",
15632                 sizeof(struct DRSUAPI_GET_OBJECT_EXISTENCE),
15633                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE,
15634                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE,
15635                 (ndr_print_function_t) ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE,
15636                 false,
15637         },
15638         {
15639                 "drsuapi_QuerySitesByCost",
15640                 sizeof(struct drsuapi_QuerySitesByCost),
15641                 (ndr_push_flags_fn_t) ndr_push_drsuapi_QuerySitesByCost,
15642                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_QuerySitesByCost,
15643                 (ndr_print_function_t) ndr_print_drsuapi_QuerySitesByCost,
15644                 false,
15645         },
15646         { NULL, 0, NULL, NULL, NULL, false }
15647 };
15648
15649 static const char * const drsuapi_endpoint_strings[] = {
15650         "ncacn_np:[\\pipe\\lsass]",
15651         "ncacn_np:[\\pipe\\protected_storage]",
15652         "ncacn_ip_tcp:",
15653         "ncalrpc:",
15654 };
15655
15656 static const struct ndr_interface_string_array drsuapi_endpoints = {
15657         .count  = 4,
15658         .names  = drsuapi_endpoint_strings
15659 };
15660
15661 static const char * const drsuapi_authservice_strings[] = {
15662         "ldap",
15663 };
15664
15665 static const struct ndr_interface_string_array drsuapi_authservices = {
15666         .count  = 1,
15667         .names  = drsuapi_authservice_strings
15668 };
15669
15670
15671 const struct ndr_interface_table ndr_table_drsuapi = {
15672         .name           = "drsuapi",
15673         .syntax_id      = {
15674                 {0xe3514235,0x4b06,0x11d1,{0xab,0x04},{0x00,0xc0,0x4f,0xc2,0xdc,0xd2}},
15675                 NDR_DRSUAPI_VERSION
15676         },
15677         .helpstring     = NDR_DRSUAPI_HELPSTRING,
15678         .num_calls      = 25,
15679         .calls          = drsuapi_calls,
15680         .endpoints      = &drsuapi_endpoints,
15681         .authservices   = &drsuapi_authservices
15682 };
15683