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_SYNC_BYNAME", DRSUAPI_DRS_SYNC_BYNAME, r);
  46         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_REF_OK", DRSUAPI_DRS_REF_OK, r);
  47         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_NOW", DRSUAPI_DRS_FULL_SYNC_NOW, r);
  48         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NO_SOURCE", DRSUAPI_DRS_NO_SOURCE, r);
  49         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS", DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS, r);
  50         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_PACKET", DRSUAPI_DRS_FULL_SYNC_PACKET, r);
  51         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_REQUEUE", DRSUAPI_DRS_SYNC_REQUEUE, r);
  52         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_URGENT", DRSUAPI_DRS_SYNC_URGENT, r);
  53         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_REF_GCSPN", DRSUAPI_DRS_REF_GCSPN, r);
  54         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NO_DISCARD", DRSUAPI_DRS_NO_DISCARD, r);
  55         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NEVER_SYNCED", DRSUAPI_DRS_NEVER_SYNCED, r);
  56         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING", DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING, r);
  57         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_INIT_SYNC_NOW", DRSUAPI_DRS_INIT_SYNC_NOW, r);
  58         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_PREEMPTED", DRSUAPI_DRS_PREEMPTED, r);
  59         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_FORCED", DRSUAPI_DRS_SYNC_FORCED, r);
  60         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DISABLE_AUTO_SYNC", DRSUAPI_DRS_DISABLE_AUTO_SYNC, r);
  61         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DISABLE_PERIODIC_SYNC", DRSUAPI_DRS_DISABLE_PERIODIC_SYNC, r);
  62         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_USE_COMPRESSION", DRSUAPI_DRS_USE_COMPRESSION, r);
  63         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NEVER_NOTIFY", DRSUAPI_DRS_NEVER_NOTIFY, r);
  64         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_PAS", DRSUAPI_DRS_SYNC_PAS, r);
  65         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_ALL_GROUP_MEMBERSHIP", DRSUAPI_DRS_GET_ALL_GROUP_MEMBERSHIP, r);
  66         ndr->depth--;
  67 }
  68
  69 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  70 {
  71         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  72         return NDR_ERR_SUCCESS;
  73 }
  74
  75 static enum ndr_err_code ndr_pull_drsuapi_SupportedExtensions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  76 {
  77         uint32_t v;
  78         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  79         *r = v;
  80         return NDR_ERR_SUCCESS;
  81 }
  82
  83 _PUBLIC_ void ndr_print_drsuapi_SupportedExtensions(struct ndr_print *ndr, const char *name, uint32_t r)
  84 {
  85         ndr_print_uint32(ndr, name, r);
  86         ndr->depth++;
  87         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_BASE", DRSUAPI_SUPPORTED_EXTENSION_BASE, r);
  88         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION", DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION, r);
  89         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI", DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI, r);
  90         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2", DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2, r);
  91         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS", DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS, r);
  92         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1, r);
  93         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION", DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION, r);
  94         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY, r);
  95         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE", DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE, r);
  96         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2, r);
  97         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION", DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION, r);
  98         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2, r);
  99         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);
 100         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND", DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND, r);
 101         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO", DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO, r);
 102         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION", DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION, r);
 103         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01, r);
 104         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP", DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP, r);
 105         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY", DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY, r);
 106         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3", DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3, r);
 107         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V5", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V5, r);
 108         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2", DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2, r);
 109         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6, r);
 110         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS", DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS, r);
 111         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8, r);
 112         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5, r);
 113         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6, r);
 114         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3, r);
 115         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7, r);
 116         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT", DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT, r);
 117         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS", DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS, r);
 118         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V10", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V10, r);
 119         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_40000000", DRSUAPI_SUPPORTED_EXTENSION_40000000, r);
 120         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_80000000", DRSUAPI_SUPPORTED_EXTENSION_80000000, r);
 121         ndr->depth--;
 122 }
 123
 124 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensionsExt(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 125 {
 126         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 127         return NDR_ERR_SUCCESS;
 128 }
 129
 130 static enum ndr_err_code ndr_pull_drsuapi_SupportedExtensionsExt(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 131 {
 132         uint32_t v;
 133         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 134         *r = v;
 135         return NDR_ERR_SUCCESS;
 136 }
 137
 138 _PUBLIC_ void ndr_print_drsuapi_SupportedExtensionsExt(struct ndr_print *ndr, const char *name, uint32_t r)
 139 {
 140         ndr_print_uint32(ndr, name, r);
 141         ndr->depth++;
 142         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADAM", DRSUAPI_SUPPORTED_EXTENSION_ADAM, r);
 143         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_LH_BETA2", DRSUAPI_SUPPORTED_EXTENSION_LH_BETA2, r);
 144         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_RECYCLE_BIN", DRSUAPI_SUPPORTED_EXTENSION_RECYCLE_BIN, r);
 145         ndr->depth--;
 146 }
 147
 148 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo24(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo24 *r)
 149 {
 150         if (ndr_flags & NDR_SCALARS) {
 151                 NDR_CHECK(ndr_push_align(ndr, 4));
 152                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 153                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 155                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 156         }
 157         if (ndr_flags & NDR_BUFFERS) {
 158         }
 159         return NDR_ERR_SUCCESS;
 160 }
 161
 162 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo24(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo24 *r)
 163 {
 164         if (ndr_flags & NDR_SCALARS) {
 165                 NDR_CHECK(ndr_pull_align(ndr, 4));
 166                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 167                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 169                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 170         }
 171         if (ndr_flags & NDR_BUFFERS) {
 172         }
 173         return NDR_ERR_SUCCESS;
 174 }
 175
 176 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo24(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo24 *r)
 177 {
 178         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo24");
 179         ndr->depth++;
 180         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 181         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 182         ndr_print_uint32(ndr, "pid", r->pid);
 183         ndr->depth--;
 184 }
 185
 186 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo28(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo28 *r)
 187 {
 188         if (ndr_flags & NDR_SCALARS) {
 189                 NDR_CHECK(ndr_push_align(ndr, 4));
 190                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 191                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 192                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 193                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 194                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 195         }
 196         if (ndr_flags & NDR_BUFFERS) {
 197         }
 198         return NDR_ERR_SUCCESS;
 199 }
 200
 201 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo28(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo28 *r)
 202 {
 203         if (ndr_flags & NDR_SCALARS) {
 204                 NDR_CHECK(ndr_pull_align(ndr, 4));
 205                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 206                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 207                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 208                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 209                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 210         }
 211         if (ndr_flags & NDR_BUFFERS) {
 212         }
 213         return NDR_ERR_SUCCESS;
 214 }
 215
 216 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo28(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo28 *r)
 217 {
 218         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo28");
 219         ndr->depth++;
 220         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 221         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 222         ndr_print_uint32(ndr, "pid", r->pid);
 223         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 224         ndr->depth--;
 225 }
 226
 227 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo48(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo48 *r)
 228 {
 229         if (ndr_flags & NDR_SCALARS) {
 230                 NDR_CHECK(ndr_push_align(ndr, 4));
 231                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 232                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 235                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, r->supported_extensions_ext));
 236                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 237                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 238         }
 239         if (ndr_flags & NDR_BUFFERS) {
 240         }
 241         return NDR_ERR_SUCCESS;
 242 }
 243
 244 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo48(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo48 *r)
 245 {
 246         if (ndr_flags & NDR_SCALARS) {
 247                 NDR_CHECK(ndr_pull_align(ndr, 4));
 248                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 249                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 251                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 252                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, &r->supported_extensions_ext));
 253                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 254                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 255         }
 256         if (ndr_flags & NDR_BUFFERS) {
 257         }
 258         return NDR_ERR_SUCCESS;
 259 }
 260
 261 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo48(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo48 *r)
 262 {
 263         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo48");
 264         ndr->depth++;
 265         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 266         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 267         ndr_print_uint32(ndr, "pid", r->pid);
 268         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 269         ndr_print_drsuapi_SupportedExtensionsExt(ndr, "supported_extensions_ext", r->supported_extensions_ext);
 270         ndr_print_GUID(ndr, "config_dn_guid", &r->config_dn_guid);
 271         ndr->depth--;
 272 }
 273
 274 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoFallBack(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoFallBack *r)
 275 {
 276         if (ndr_flags & NDR_SCALARS) {
 277                 NDR_CHECK(ndr_push_align(ndr, 4));
 278                 {
 279                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 280                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 281                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->info));
 282                         ndr->flags = _flags_save_DATA_BLOB;
 283                 }
 284                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 285         }
 286         if (ndr_flags & NDR_BUFFERS) {
 287         }
 288         return NDR_ERR_SUCCESS;
 289 }
 290
 291 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoFallBack(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoFallBack *r)
 292 {
 293         if (ndr_flags & NDR_SCALARS) {
 294                 NDR_CHECK(ndr_pull_align(ndr, 4));
 295                 {
 296                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 297                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 298                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->info));
 299                         ndr->flags = _flags_save_DATA_BLOB;
 300                 }
 301                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 302         }
 303         if (ndr_flags & NDR_BUFFERS) {
 304         }
 305         return NDR_ERR_SUCCESS;
 306 }
 307
 308 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoFallBack(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoFallBack *r)
 309 {
 310         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoFallBack");
 311         ndr->depth++;
 312         ndr_print_DATA_BLOB(ndr, "info", r->info);
 313         ndr->depth--;
 314 }
 315
 316 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsBindInfo *r)
 317 {
 318         if (ndr_flags & NDR_SCALARS) {
 319                 int level = ndr_push_get_switch_value(ndr, r);
 320                 NDR_CHECK(ndr_push_union_align(ndr, 1));
 321                 switch (level) {
 322                         case 24: {
 323                                 {
 324                                         struct ndr_push *_ndr_info24;
 325                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info24, 4, -1));
 326                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 327                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info24, 4, -1));
 328                                 }
 329                         break; }
 330
 331                         case 28: {
 332                                 {
 333                                         struct ndr_push *_ndr_info28;
 334                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info28, 4, -1));
 335                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 336                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info28, 4, -1));
 337                                 }
 338                         break; }
 339
 340                         case 48: {
 341                                 {
 342                                         struct ndr_push *_ndr_info48;
 343                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info48, 4, -1));
 344                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 345                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info48, 4, -1));
 346                                 }
 347                         break; }
 348
 349                         default: {
 350                                 {
 351                                         struct ndr_push *_ndr_FallBack;
 352                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 353                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 354                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 355                                 }
 356                         break; }
 357
 358                 }
 359         }
 360         if (ndr_flags & NDR_BUFFERS) {
 361                 int level = ndr_push_get_switch_value(ndr, r);
 362                 switch (level) {
 363                         case 24:
 364                         break;
 365
 366                         case 28:
 367                         break;
 368
 369                         case 48:
 370                         break;
 371
 372                         default:
 373                         break;
 374
 375                 }
 376         }
 377         return NDR_ERR_SUCCESS;
 378 }
 379
 380 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsBindInfo *r)
 381 {
 382         int level;
 383         level = ndr_pull_get_switch_value(ndr, r);
 384         if (ndr_flags & NDR_SCALARS) {
 385                 NDR_CHECK(ndr_pull_union_align(ndr, 1));
 386                 switch (level) {
 387                         case 24: {
 388                                 {
 389                                         struct ndr_pull *_ndr_info24;
 390                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info24, 4, -1));
 391                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 392                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info24, 4, -1));
 393                                 }
 394                         break; }
 395
 396                         case 28: {
 397                                 {
 398                                         struct ndr_pull *_ndr_info28;
 399                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info28, 4, -1));
 400                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 401                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info28, 4, -1));
 402                                 }
 403                         break; }
 404
 405                         case 48: {
 406                                 {
 407                                         struct ndr_pull *_ndr_info48;
 408                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info48, 4, -1));
 409                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 410                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info48, 4, -1));
 411                                 }
 412                         break; }
 413
 414                         default: {
 415                                 {
 416                                         struct ndr_pull *_ndr_FallBack;
 417                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 418                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 419                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 420                                 }
 421                         break; }
 422
 423                 }
 424         }
 425         if (ndr_flags & NDR_BUFFERS) {
 426                 switch (level) {
 427                         case 24:
 428                         break;
 429
 430                         case 28:
 431                         break;
 432
 433                         case 48:
 434                         break;
 435
 436                         default:
 437                         break;
 438
 439                 }
 440         }
 441         return NDR_ERR_SUCCESS;
 442 }
 443
 444 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsBindInfo *r)
 445 {
 446         int level;
 447         level = ndr_print_get_switch_value(ndr, r);
 448         ndr_print_union(ndr, name, level, "drsuapi_DsBindInfo");
 449         switch (level) {
 450                 case 24:
 451                         ndr_print_drsuapi_DsBindInfo24(ndr, "info24", &r->info24);
 452                 break;
 453
 454                 case 28:
 455                         ndr_print_drsuapi_DsBindInfo28(ndr, "info28", &r->info28);
 456                 break;
 457
 458                 case 48:
 459                         ndr_print_drsuapi_DsBindInfo48(ndr, "info48", &r->info48);
 460                 break;
 461
 462                 default:
 463                         ndr_print_drsuapi_DsBindInfoFallBack(ndr, "FallBack", &r->FallBack);
 464                 break;
 465
 466         }
 467 }
 468
 469 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoCtr *r)
 470 {
 471         if (ndr_flags & NDR_SCALARS) {
 472                 NDR_CHECK(ndr_push_align(ndr, 4));
 473                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
 474                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->length));
 475                 NDR_CHECK(ndr_push_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 476                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 477         }
 478         if (ndr_flags & NDR_BUFFERS) {
 479         }
 480         return NDR_ERR_SUCCESS;
 481 }
 482
 483 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoCtr *r)
 484 {
 485         if (ndr_flags & NDR_SCALARS) {
 486                 NDR_CHECK(ndr_pull_align(ndr, 4));
 487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 488                 if (r->length < 1 || r->length > 10000) {
 489                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 490                 }
 491                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->length));
 492                 NDR_CHECK(ndr_pull_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 493                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 494         }
 495         if (ndr_flags & NDR_BUFFERS) {
 496         }
 497         return NDR_ERR_SUCCESS;
 498 }
 499
 500 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoCtr *r)
 501 {
 502         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoCtr");
 503         ndr->depth++;
 504         ndr_print_uint32(ndr, "length", r->length);
 505         ndr_print_set_switch_value(ndr, &r->info, r->length);
 506         ndr_print_drsuapi_DsBindInfo(ndr, "info", &r->info);
 507         ndr->depth--;
 508 }
 509
 510 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier *r)
 511 {
 512         if (ndr_flags & NDR_SCALARS) {
 513                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, strlen_m(r->dn) + 1));
 514                 NDR_CHECK(ndr_push_align(ndr, 4));
 515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->iconv_convenience, ndr->flags) - 4));
 516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
 517                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
 518                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
 519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
 520                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
 521                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 522         }
 523         if (ndr_flags & NDR_BUFFERS) {
 524                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
 525         }
 526         return NDR_ERR_SUCCESS;
 527 }
 528
 529 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier *r)
 530 {
 531         if (ndr_flags & NDR_SCALARS) {
 532                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dn));
 533                 NDR_CHECK(ndr_pull_align(ndr, 4));
 534                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
 535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
 536                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
 537                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
 538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
 539                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, ndr_get_array_size(ndr, &r->dn), sizeof(uint16_t), CH_UTF16));
 540                 if (r->dn) {
 541                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->dn, r->__ndr_size_dn + 1));
 542                 }
 543                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 544         }
 545         if (ndr_flags & NDR_BUFFERS) {
 546                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
 547         }
 548         return NDR_ERR_SUCCESS;
 549 }
 550
 551 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier *r)
 552 {
 553         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier");
 554         ndr->depth++;
 555         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);
 556         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);
 557         ndr_print_GUID(ndr, "guid", &r->guid);
 558         ndr_print_dom_sid28(ndr, "sid", &r->sid);
 559         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
 560         ndr_print_string(ndr, "dn", r->dn);
 561         ndr->depth--;
 562 }
 563
 564 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier(const struct drsuapi_DsReplicaObjectIdentifier *r, struct smb_iconv_convenience *ic, int flags)
 565 {
 566         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier, ic);
 567 }
 568
 569 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 570 {
 571         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 572         return NDR_ERR_SUCCESS;
 573 }
 574
 575 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 576 {
 577         uint32_t v;
 578         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 579         *r = v;
 580         return NDR_ERR_SUCCESS;
 581 }
 582
 583 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncOptions(struct ndr_print *ndr, const char *name, uint32_t r)
 584 {
 585         ndr_print_uint32(ndr, name, r);
 586         ndr->depth++;
 587         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION, r);
 588         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_WRITEABLE", DRSUAPI_DS_REPLICA_SYNC_WRITEABLE, r);
 589         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PERIODIC", DRSUAPI_DS_REPLICA_SYNC_PERIODIC, r);
 590         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING", DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING, r);
 591         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES", DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES, r);
 592         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL", DRSUAPI_DS_REPLICA_SYNC_FULL, r);
 593         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_URGENT", DRSUAPI_DS_REPLICA_SYNC_URGENT, r);
 594         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD", DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD, r);
 595         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FORCE", DRSUAPI_DS_REPLICA_SYNC_FORCE, r);
 596         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE", DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE, r);
 597         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED", DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED, r);
 598         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_TWO_WAY", DRSUAPI_DS_REPLICA_SYNC_TWO_WAY, r);
 599         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY", DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY, r);
 600         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL", DRSUAPI_DS_REPLICA_SYNC_INITIAL, r);
 601         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION", DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION, r);
 602         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ABANDONED", DRSUAPI_DS_REPLICA_SYNC_ABANDONED, r);
 603         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS, r);
 604         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET", DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET, r);
 605         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_REQUEUE", DRSUAPI_DS_REPLICA_SYNC_REQUEUE, r);
 606         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION", DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION, r);
 607         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA, r);
 608         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_CRITICAL", DRSUAPI_DS_REPLICA_SYNC_CRITICAL, r);
 609         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS, r);
 610         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PREEMPTED", DRSUAPI_DS_REPLICA_SYNC_PREEMPTED, r);
 611         ndr->depth--;
 612 }
 613
 614 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaSyncRequest1 *r)
 615 {
 616         if (ndr_flags & NDR_SCALARS) {
 617                 NDR_CHECK(ndr_push_align(ndr, 5));
 618                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
 619                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 620                 {
 621                         uint32_t _flags_save_string = ndr->flags;
 622                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 623                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_info));
 624                         ndr->flags = _flags_save_string;
 625                 }
 626                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
 627                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 628         }
 629         if (ndr_flags & NDR_BUFFERS) {
 630                 if (r->naming_context) {
 631                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 632                 }
 633                 {
 634                         uint32_t _flags_save_string = ndr->flags;
 635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 636                         if (r->other_info) {
 637                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->other_info));
 638                         }
 639                         ndr->flags = _flags_save_string;
 640                 }
 641         }
 642         return NDR_ERR_SUCCESS;
 643 }
 644
 645 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaSyncRequest1 *r)
 646 {
 647         uint32_t _ptr_naming_context;
 648         TALLOC_CTX *_mem_save_naming_context_0;
 649         uint32_t _ptr_other_info;
 650         TALLOC_CTX *_mem_save_other_info_0;
 651         if (ndr_flags & NDR_SCALARS) {
 652                 NDR_CHECK(ndr_pull_align(ndr, 5));
 653                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
 654                 if (_ptr_naming_context) {
 655                         NDR_PULL_ALLOC(ndr, r->naming_context);
 656                 } else {
 657                         r->naming_context = NULL;
 658                 }
 659                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 660                 {
 661                         uint32_t _flags_save_string = ndr->flags;
 662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 663                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_info));
 664                         if (_ptr_other_info) {
 665                                 NDR_PULL_ALLOC(ndr, r->other_info);
 666                         } else {
 667                                 r->other_info = NULL;
 668                         }
 669                         ndr->flags = _flags_save_string;
 670                 }
 671                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
 672                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 673         }
 674         if (ndr_flags & NDR_BUFFERS) {
 675                 if (r->naming_context) {
 676                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
 677                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
 678                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 679                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
 680                 }
 681                 {
 682                         uint32_t _flags_save_string = ndr->flags;
 683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 684                         if (r->other_info) {
 685                                 _mem_save_other_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 686                                 NDR_PULL_SET_MEM_CTX(ndr, r->other_info, 0);
 687                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->other_info));
 688                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_info_0, 0);
 689                         }
 690                         ndr->flags = _flags_save_string;
 691                 }
 692         }
 693         return NDR_ERR_SUCCESS;
 694 }
 695
 696 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaSyncRequest1 *r)
 697 {
 698         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSyncRequest1");
 699         ndr->depth++;
 700         ndr_print_ptr(ndr, "naming_context", r->naming_context);
 701         ndr->depth++;
 702         if (r->naming_context) {
 703                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
 704         }
 705         ndr->depth--;
 706         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
 707         ndr_print_ptr(ndr, "other_info", r->other_info);
 708         ndr->depth++;
 709         if (r->other_info) {
 710                 ndr_print_string(ndr, "other_info", r->other_info);
 711         }
 712         ndr->depth--;
 713         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
 714         ndr->depth--;
 715 }
 716
 717 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaSyncRequest *r)
 718 {
 719         if (ndr_flags & NDR_SCALARS) {
 720                 int level = ndr_push_get_switch_value(ndr, r);
 721                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
 722                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 723                 switch (level) {
 724                         case 1: {
 725                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 726                         break; }
 727
 728                         default:
 729                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 730                 }
 731         }
 732         if (ndr_flags & NDR_BUFFERS) {
 733                 int level = ndr_push_get_switch_value(ndr, r);
 734                 switch (level) {
 735                         case 1:
 736                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 737                         break;
 738
 739                         default:
 740                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 741                 }
 742         }
 743         return NDR_ERR_SUCCESS;
 744 }
 745
 746 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaSyncRequest *r)
 747 {
 748         int level;
 749         int32_t _level;
 750         level = ndr_pull_get_switch_value(ndr, r);
 751         if (ndr_flags & NDR_SCALARS) {
 752                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
 753                 if (_level != level) {
 754                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 755                 }
 756                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 757                 switch (level) {
 758                         case 1: {
 759                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 760                         break; }
 761
 762                         default:
 763                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 764                 }
 765         }
 766         if (ndr_flags & NDR_BUFFERS) {
 767                 switch (level) {
 768                         case 1:
 769                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 770                         break;
 771
 772                         default:
 773                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 774                 }
 775         }
 776         return NDR_ERR_SUCCESS;
 777 }
 778
 779 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaSyncRequest *r)
 780 {
 781         int level;
 782         level = ndr_print_get_switch_value(ndr, r);
 783         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaSyncRequest");
 784         switch (level) {
 785                 case 1:
 786                         ndr_print_drsuapi_DsReplicaSyncRequest1(ndr, "req1", &r->req1);
 787                 break;
 788
 789                 default:
 790                         ndr_print_bad_level(ndr, name, level);
 791         }
 792 }
 793
 794 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaHighWaterMark(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaHighWaterMark *r)
 795 {
 796         if (ndr_flags & NDR_SCALARS) {
 797                 NDR_CHECK(ndr_push_align(ndr, 8));
 798                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
 799                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->reserved_usn));
 800                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 801                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 802         }
 803         if (ndr_flags & NDR_BUFFERS) {
 804         }
 805         return NDR_ERR_SUCCESS;
 806 }
 807
 808 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaHighWaterMark(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaHighWaterMark *r)
 809 {
 810         if (ndr_flags & NDR_SCALARS) {
 811                 NDR_CHECK(ndr_pull_align(ndr, 8));
 812                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
 813                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->reserved_usn));
 814                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 815                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 816         }
 817         if (ndr_flags & NDR_BUFFERS) {
 818         }
 819         return NDR_ERR_SUCCESS;
 820 }
 821
 822 _PUBLIC_ void ndr_print_drsuapi_DsReplicaHighWaterMark(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaHighWaterMark *r)
 823 {
 824         ndr_print_struct(ndr, name, "drsuapi_DsReplicaHighWaterMark");
 825         ndr->depth++;
 826         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
 827         ndr_print_hyper(ndr, "reserved_usn", r->reserved_usn);
 828         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 829         ndr->depth--;
 830 }
 831
 832 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor *r)
 833 {
 834         if (ndr_flags & NDR_SCALARS) {
 835                 NDR_CHECK(ndr_push_align(ndr, 8));
 836                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 837                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 838                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 839         }
 840         if (ndr_flags & NDR_BUFFERS) {
 841         }
 842         return NDR_ERR_SUCCESS;
 843 }
 844
 845 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor *r)
 846 {
 847         if (ndr_flags & NDR_SCALARS) {
 848                 NDR_CHECK(ndr_pull_align(ndr, 8));
 849                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 850                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 851                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 852         }
 853         if (ndr_flags & NDR_BUFFERS) {
 854         }
 855         return NDR_ERR_SUCCESS;
 856 }
 857
 858 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor *r)
 859 {
 860         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor");
 861         ndr->depth++;
 862         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
 863         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 864         ndr->depth--;
 865 }
 866
 867 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtrEx *r)
 868 {
 869         uint32_t cntr_cursors_0;
 870         if (ndr_flags & NDR_SCALARS) {
 871                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 872                 NDR_CHECK(ndr_push_align(ndr, 8));
 873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
 874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 877                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 878                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 879                 }
 880                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 881         }
 882         if (ndr_flags & NDR_BUFFERS) {
 883         }
 884         return NDR_ERR_SUCCESS;
 885 }
 886
 887 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtrEx *r)
 888 {
 889         uint32_t cntr_cursors_0;
 890         TALLOC_CTX *_mem_save_cursors_0;
 891         if (ndr_flags & NDR_SCALARS) {
 892                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
 893                 NDR_CHECK(ndr_pull_align(ndr, 8));
 894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 897                 if (r->count > 0x100000) {
 898                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 899                 }
 900                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 901                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
 902                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
 903                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
 904                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 905                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 906                 }
 907                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
 908                 if (r->cursors) {
 909                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
 910                 }
 911                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 912         }
 913         if (ndr_flags & NDR_BUFFERS) {
 914         }
 915         return NDR_ERR_SUCCESS;
 916 }
 917
 918 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtrEx *r)
 919 {
 920         uint32_t cntr_cursors_0;
 921         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtrEx");
 922         ndr->depth++;
 923         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
 924         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
 925         ndr_print_uint32(ndr, "count", r->count);
 926         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
 927         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
 928         ndr->depth++;
 929         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
 930                 char *idx_0=NULL;
 931                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
 932                         ndr_print_drsuapi_DsReplicaCursor(ndr, "cursors", &r->cursors[cntr_cursors_0]);
 933                         free(idx_0);
 934                 }
 935         }
 936         ndr->depth--;
 937         ndr->depth--;
 938 }
 939
 940 static enum ndr_err_code ndr_push_drsuapi_DsExtendedOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation r)
 941 {
 942         {
 943                 uint32_t _flags_save_ENUM = ndr->flags;
 944                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 945                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 946                 ndr->flags = _flags_save_ENUM;
 947         }
 948         return NDR_ERR_SUCCESS;
 949 }
 950
 951 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation *r)
 952 {
 953         uint32_t v;
 954         {
 955                 uint32_t _flags_save_ENUM = ndr->flags;
 956                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 957                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 958                 *r = v;
 959                 ndr->flags = _flags_save_ENUM;
 960         }
 961         return NDR_ERR_SUCCESS;
 962 }
 963
 964 _PUBLIC_ void ndr_print_drsuapi_DsExtendedOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedOperation r)
 965 {
 966         const char *val = NULL;
 967
 968         {
 969                 uint32_t _flags_save_ENUM = ndr->flags;
 970                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 971                 switch (r) {
 972                         case DRSUAPI_EXOP_NONE: val = "DRSUAPI_EXOP_NONE"; break;
 973                         case DRSUAPI_EXOP_FSMO_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_REQ_ROLE"; break;
 974                         case DRSUAPI_EXOP_FSMO_RID_ALLOC: val = "DRSUAPI_EXOP_FSMO_RID_ALLOC"; break;
 975                         case DRSUAPI_EXOP_FSMO_RID_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_RID_REQ_ROLE"; break;
 976                         case DRSUAPI_EXOP_FSMO_REQ_PDC: val = "DRSUAPI_EXOP_FSMO_REQ_PDC"; break;
 977                         case DRSUAPI_EXOP_FSMO_ABANDON_ROLE: val = "DRSUAPI_EXOP_FSMO_ABANDON_ROLE"; break;
 978                         case DRSUAPI_EXOP_REPL_OBJ: val = "DRSUAPI_EXOP_REPL_OBJ"; break;
 979                         case DRSUAPI_EXOP_REPL_SECRET: val = "DRSUAPI_EXOP_REPL_SECRET"; break;
 980                 }
 981                 ndr_print_enum(ndr, name, "ENUM", val, r);
 982                 ndr->flags = _flags_save_ENUM;
 983         }
 984 }
 985
 986 static enum ndr_err_code ndr_push_drsuapi_DsExtendedError(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedError r)
 987 {
 988         {
 989                 uint32_t _flags_save_ENUM = ndr->flags;
 990                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 991                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 992                 ndr->flags = _flags_save_ENUM;
 993         }
 994         return NDR_ERR_SUCCESS;
 995 }
 996
 997 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedError(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedError *r)
 998 {
 999         uint32_t v;
1000         {
1001                 uint32_t _flags_save_ENUM = ndr->flags;
1002                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1003                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1004                 *r = v;
1005                 ndr->flags = _flags_save_ENUM;
1006         }
1007         return NDR_ERR_SUCCESS;
1008 }
1009
1010 _PUBLIC_ void ndr_print_drsuapi_DsExtendedError(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedError r)
1011 {
1012         const char *val = NULL;
1013
1014         {
1015                 uint32_t _flags_save_ENUM = ndr->flags;
1016                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1017                 switch (r) {
1018                         case DRSUAPI_EXOP_ERR_NONE: val = "DRSUAPI_EXOP_ERR_NONE"; break;
1019                         case DRSUAPI_EXOP_ERR_SUCCESS: val = "DRSUAPI_EXOP_ERR_SUCCESS"; break;
1020                         case DRSUAPI_EXOP_ERR_UNKNOWN_OP: val = "DRSUAPI_EXOP_ERR_UNKNOWN_OP"; break;
1021                         case DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER: val = "DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER"; break;
1022                         case DRSUAPI_EXOP_ERR_UPDATE_ERR: val = "DRSUAPI_EXOP_ERR_UPDATE_ERR"; break;
1023                         case DRSUAPI_EXOP_ERR_EXCEPTION: val = "DRSUAPI_EXOP_ERR_EXCEPTION"; break;
1024                         case DRSUAPI_EXOP_ERR_UNKNOWN_CALLER: val = "DRSUAPI_EXOP_ERR_UNKNOWN_CALLER"; break;
1025                         case DRSUAPI_EXOP_ERR_RID_ALLOC: val = "DRSUAPI_EXOP_ERR_RID_ALLOC"; break;
1026                         case DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED: val = "DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED"; break;
1027                         case DRSUAPI_EXOP_ERR_FMSO_PENDING_OP: val = "DRSUAPI_EXOP_ERR_FMSO_PENDING_OP"; break;
1028                         case DRSUAPI_EXOP_ERR_MISMATCH: val = "DRSUAPI_EXOP_ERR_MISMATCH"; break;
1029                         case DRSUAPI_EXOP_ERR_COULDNT_CONTACT: val = "DRSUAPI_EXOP_ERR_COULDNT_CONTACT"; break;
1030                         case DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES: val = "DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES"; break;
1031                         case DRSUAPI_EXOP_ERR_DIR_ERROR: val = "DRSUAPI_EXOP_ERR_DIR_ERROR"; break;
1032                         case DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS: val = "DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS"; break;
1033                         case DRSUAPI_EXOP_ERR_ACCESS_DENIED: val = "DRSUAPI_EXOP_ERR_ACCESS_DENIED"; break;
1034                         case DRSUAPI_EXOP_ERR_PARAM_ERROR: val = "DRSUAPI_EXOP_ERR_PARAM_ERROR"; break;
1035                 }
1036                 ndr_print_enum(ndr, name, "ENUM", val, r);
1037                 ndr->flags = _flags_save_ENUM;
1038         }
1039 }
1040
1041 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest5(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest5 *r)
1042 {
1043         if (ndr_flags & NDR_SCALARS) {
1044                 NDR_CHECK(ndr_push_align(ndr, 8));
1045                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1046                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1047                 if (r->naming_context == NULL) {
1048                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1049                 }
1050                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1051                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1052                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1053                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
1054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1056                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1057                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1058                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1059         }
1060         if (ndr_flags & NDR_BUFFERS) {
1061                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1062                 if (r->uptodateness_vector) {
1063                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1064                 }
1065         }
1066         return NDR_ERR_SUCCESS;
1067 }
1068
1069 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest5(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest5 *r)
1070 {
1071         uint32_t _ptr_naming_context;
1072         TALLOC_CTX *_mem_save_naming_context_0;
1073         uint32_t _ptr_uptodateness_vector;
1074         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1075         if (ndr_flags & NDR_SCALARS) {
1076                 NDR_CHECK(ndr_pull_align(ndr, 8));
1077                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1078                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1079                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1080                 if (_ptr_naming_context) {
1081                         NDR_PULL_ALLOC(ndr, r->naming_context);
1082                 } else {
1083                         r->naming_context = NULL;
1084                 }
1085                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1086                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1087                 if (_ptr_uptodateness_vector) {
1088                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1089                 } else {
1090                         r->uptodateness_vector = NULL;
1091                 }
1092                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
1093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1095                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1096                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1097                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1098         }
1099         if (ndr_flags & NDR_BUFFERS) {
1100                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1101                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1102                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1103                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1104                 if (r->uptodateness_vector) {
1105                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1106                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1107                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1108                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1109                 }
1110         }
1111         return NDR_ERR_SUCCESS;
1112 }
1113
1114 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest5(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest5 *r)
1115 {
1116         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest5");
1117         ndr->depth++;
1118         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1119         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1120         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1121         ndr->depth++;
1122         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1123         ndr->depth--;
1124         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1125         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1126         ndr->depth++;
1127         if (r->uptodateness_vector) {
1128                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1129         }
1130         ndr->depth--;
1131         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
1132         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1133         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1134         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1135         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1136         ndr->depth--;
1137 }
1138
1139 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOID(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOID *r)
1140 {
1141         if (ndr_flags & NDR_SCALARS) {
1142                 NDR_CHECK(ndr_push_align(ndr, 5));
1143                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
1144                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary_oid));
1145                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1146         }
1147         if (ndr_flags & NDR_BUFFERS) {
1148                 if (r->binary_oid) {
1149                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
1150                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->binary_oid, r->length));
1151                 }
1152         }
1153         return NDR_ERR_SUCCESS;
1154 }
1155
1156 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOID(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOID *r)
1157 {
1158         uint32_t _ptr_binary_oid;
1159         TALLOC_CTX *_mem_save_binary_oid_0;
1160         if (ndr_flags & NDR_SCALARS) {
1161                 NDR_CHECK(ndr_pull_align(ndr, 5));
1162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
1163                 if (r->length > 10000) {
1164                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1165                 }
1166                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_oid));
1167                 if (_ptr_binary_oid) {
1168                         NDR_PULL_ALLOC(ndr, r->binary_oid);
1169                 } else {
1170                         r->binary_oid = NULL;
1171                 }
1172                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1173         }
1174         if (ndr_flags & NDR_BUFFERS) {
1175                 if (r->binary_oid) {
1176                         _mem_save_binary_oid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1177                         NDR_PULL_SET_MEM_CTX(ndr, r->binary_oid, 0);
1178                         NDR_CHECK(ndr_pull_array_size(ndr, &r->binary_oid));
1179                         NDR_PULL_ALLOC_N(ndr, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid));
1180                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid)));
1181                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_oid_0, 0);
1182                 }
1183                 if (r->binary_oid) {
1184                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->binary_oid, r->length));
1185                 }
1186         }
1187         return NDR_ERR_SUCCESS;
1188 }
1189
1190 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping *r)
1191 {
1192         if (ndr_flags & NDR_SCALARS) {
1193                 NDR_CHECK(ndr_push_align(ndr, 5));
1194                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id_prefix));
1195                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1196                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1197         }
1198         if (ndr_flags & NDR_BUFFERS) {
1199                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1200         }
1201         return NDR_ERR_SUCCESS;
1202 }
1203
1204 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping *r)
1205 {
1206         if (ndr_flags & NDR_SCALARS) {
1207                 NDR_CHECK(ndr_pull_align(ndr, 5));
1208                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id_prefix));
1209                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1210                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1211         }
1212         if (ndr_flags & NDR_BUFFERS) {
1213                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1214         }
1215         return NDR_ERR_SUCCESS;
1216 }
1217
1218 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping *r)
1219 {
1220         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping");
1221         ndr->depth++;
1222         ndr_print_uint32(ndr, "id_prefix", r->id_prefix);
1223         ndr_print_drsuapi_DsReplicaOID(ndr, "oid", &r->oid);
1224         ndr->depth--;
1225 }
1226
1227 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1228 {
1229         uint32_t cntr_mappings_1;
1230         if (ndr_flags & NDR_SCALARS) {
1231                 NDR_CHECK(ndr_push_align(ndr, 5));
1232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
1233                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mappings));
1234                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1235         }
1236         if (ndr_flags & NDR_BUFFERS) {
1237                 if (r->mappings) {
1238                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_mappings));
1239                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1240                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1241                         }
1242                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1243                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1244                         }
1245                 }
1246         }
1247         return NDR_ERR_SUCCESS;
1248 }
1249
1250 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1251 {
1252         uint32_t _ptr_mappings;
1253         uint32_t cntr_mappings_1;
1254         TALLOC_CTX *_mem_save_mappings_0;
1255         TALLOC_CTX *_mem_save_mappings_1;
1256         if (ndr_flags & NDR_SCALARS) {
1257                 NDR_CHECK(ndr_pull_align(ndr, 5));
1258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mappings));
1259                 if (r->num_mappings > 0x100000) {
1260                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1261                 }
1262                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mappings));
1263                 if (_ptr_mappings) {
1264                         NDR_PULL_ALLOC(ndr, r->mappings);
1265                 } else {
1266                         r->mappings = NULL;
1267                 }
1268                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1269         }
1270         if (ndr_flags & NDR_BUFFERS) {
1271                 if (r->mappings) {
1272                         _mem_save_mappings_0 = NDR_PULL_GET_MEM_CTX(ndr);
1273                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1274                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mappings));
1275                         NDR_PULL_ALLOC_N(ndr, r->mappings, ndr_get_array_size(ndr, &r->mappings));
1276                         _mem_save_mappings_1 = NDR_PULL_GET_MEM_CTX(ndr);
1277                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1278                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1279                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1280                         }
1281                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1282                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1283                         }
1284                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_1, 0);
1285                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_0, 0);
1286                 }
1287                 if (r->mappings) {
1288                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->mappings, r->num_mappings));
1289                 }
1290         }
1291         return NDR_ERR_SUCCESS;
1292 }
1293
1294 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1295 {
1296         uint32_t cntr_mappings_1;
1297         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping_Ctr");
1298         ndr->depth++;
1299         ndr_print_uint32(ndr, "num_mappings", r->num_mappings);
1300         ndr_print_ptr(ndr, "mappings", r->mappings);
1301         ndr->depth++;
1302         if (r->mappings) {
1303                 ndr->print(ndr, "%s: ARRAY(%d)", "mappings", (int)r->num_mappings);
1304                 ndr->depth++;
1305                 for (cntr_mappings_1=0;cntr_mappings_1<r->num_mappings;cntr_mappings_1++) {
1306                         char *idx_1=NULL;
1307                         if (asprintf(&idx_1, "[%d]", cntr_mappings_1) != -1) {
1308                                 ndr_print_drsuapi_DsReplicaOIDMapping(ndr, "mappings", &r->mappings[cntr_mappings_1]);
1309                                 free(idx_1);
1310                         }
1311                 }
1312                 ndr->depth--;
1313         }
1314         ndr->depth--;
1315         ndr->depth--;
1316 }
1317
1318 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAttributeId(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsAttributeId r)
1319 {
1320         {
1321                 uint32_t _flags_save_ENUM = ndr->flags;
1322                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1323                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1324                 ndr->flags = _flags_save_ENUM;
1325         }
1326         return NDR_ERR_SUCCESS;
1327 }
1328
1329 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAttributeId(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsAttributeId *r)
1330 {
1331         uint32_t v;
1332         {
1333                 uint32_t _flags_save_ENUM = ndr->flags;
1334                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1335                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1336                 *r = v;
1337                 ndr->flags = _flags_save_ENUM;
1338         }
1339         return NDR_ERR_SUCCESS;
1340 }
1341
1342 _PUBLIC_ void ndr_print_drsuapi_DsAttributeId(struct ndr_print *ndr, const char *name, enum drsuapi_DsAttributeId r)
1343 {
1344         const char *val = NULL;
1345
1346         {
1347                 uint32_t _flags_save_ENUM = ndr->flags;
1348                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1349                 switch (r) {
1350                         case DRSUAPI_ATTRIBUTE_objectClass: val = "DRSUAPI_ATTRIBUTE_objectClass"; break;
1351                         case DRSUAPI_ATTRIBUTE_cn: val = "DRSUAPI_ATTRIBUTE_cn"; break;
1352                         case DRSUAPI_ATTRIBUTE_description: val = "DRSUAPI_ATTRIBUTE_description"; break;
1353                         case DRSUAPI_ATTRIBUTE_member: val = "DRSUAPI_ATTRIBUTE_member"; break;
1354                         case DRSUAPI_ATTRIBUTE_instanceType: val = "DRSUAPI_ATTRIBUTE_instanceType"; break;
1355                         case DRSUAPI_ATTRIBUTE_whenCreated: val = "DRSUAPI_ATTRIBUTE_whenCreated"; break;
1356                         case DRSUAPI_ATTRIBUTE_possSuperiors: val = "DRSUAPI_ATTRIBUTE_possSuperiors"; break;
1357                         case DRSUAPI_ATTRIBUTE_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_hasMasterNCs"; break;
1358                         case DRSUAPI_ATTRIBUTE_subClassOf: val = "DRSUAPI_ATTRIBUTE_subClassOf"; break;
1359                         case DRSUAPI_ATTRIBUTE_governsID: val = "DRSUAPI_ATTRIBUTE_governsID"; break;
1360                         case DRSUAPI_ATTRIBUTE_mustContain: val = "DRSUAPI_ATTRIBUTE_mustContain"; break;
1361                         case DRSUAPI_ATTRIBUTE_mayContain: val = "DRSUAPI_ATTRIBUTE_mayContain"; break;
1362                         case DRSUAPI_ATTRIBUTE_rDNAttId: val = "DRSUAPI_ATTRIBUTE_rDNAttId"; break;
1363                         case DRSUAPI_ATTRIBUTE_attributeID: val = "DRSUAPI_ATTRIBUTE_attributeID"; break;
1364                         case DRSUAPI_ATTRIBUTE_attributeSyntax: val = "DRSUAPI_ATTRIBUTE_attributeSyntax"; break;
1365                         case DRSUAPI_ATTRIBUTE_isSingleValued: val = "DRSUAPI_ATTRIBUTE_isSingleValued"; break;
1366                         case DRSUAPI_ATTRIBUTE_rangeLower: val = "DRSUAPI_ATTRIBUTE_rangeLower"; break;
1367                         case DRSUAPI_ATTRIBUTE_rangeUpper: val = "DRSUAPI_ATTRIBUTE_rangeUpper"; break;
1368                         case DRSUAPI_ATTRIBUTE_dMDLocation: val = "DRSUAPI_ATTRIBUTE_dMDLocation"; break;
1369                         case DRSUAPI_ATTRIBUTE_objectVersion: val = "DRSUAPI_ATTRIBUTE_objectVersion"; break;
1370                         case DRSUAPI_ATTRIBUTE_invocationId: val = "DRSUAPI_ATTRIBUTE_invocationId"; break;
1371                         case DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly: val = "DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly"; break;
1372                         case DRSUAPI_ATTRIBUTE_adminDisplayName: val = "DRSUAPI_ATTRIBUTE_adminDisplayName"; break;
1373                         case DRSUAPI_ATTRIBUTE_adminDescription: val = "DRSUAPI_ATTRIBUTE_adminDescription"; break;
1374                         case DRSUAPI_ATTRIBUTE_oMSyntax: val = "DRSUAPI_ATTRIBUTE_oMSyntax"; break;
1375                         case DRSUAPI_ATTRIBUTE_ntSecurityDescriptor: val = "DRSUAPI_ATTRIBUTE_ntSecurityDescriptor"; break;
1376                         case DRSUAPI_ATTRIBUTE_searchFlags: val = "DRSUAPI_ATTRIBUTE_searchFlags"; break;
1377                         case DRSUAPI_ATTRIBUTE_auxiliaryClass: val = "DRSUAPI_ATTRIBUTE_auxiliaryClass"; break;
1378                         case DRSUAPI_ATTRIBUTE_lDAPDisplayName: val = "DRSUAPI_ATTRIBUTE_lDAPDisplayName"; break;
1379                         case DRSUAPI_ATTRIBUTE_name: val = "DRSUAPI_ATTRIBUTE_name"; break;
1380                         case DRSUAPI_ATTRIBUTE_userAccountControl: val = "DRSUAPI_ATTRIBUTE_userAccountControl"; break;
1381                         case DRSUAPI_ATTRIBUTE_currentValue: val = "DRSUAPI_ATTRIBUTE_currentValue"; break;
1382                         case DRSUAPI_ATTRIBUTE_homeDirectory: val = "DRSUAPI_ATTRIBUTE_homeDirectory"; break;
1383                         case DRSUAPI_ATTRIBUTE_homeDrive: val = "DRSUAPI_ATTRIBUTE_homeDrive"; break;
1384                         case DRSUAPI_ATTRIBUTE_scriptPath: val = "DRSUAPI_ATTRIBUTE_scriptPath"; break;
1385                         case DRSUAPI_ATTRIBUTE_profilePath: val = "DRSUAPI_ATTRIBUTE_profilePath"; break;
1386                         case DRSUAPI_ATTRIBUTE_objectSid: val = "DRSUAPI_ATTRIBUTE_objectSid"; break;
1387                         case DRSUAPI_ATTRIBUTE_schemaIDGUID: val = "DRSUAPI_ATTRIBUTE_schemaIDGUID"; break;
1388                         case DRSUAPI_ATTRIBUTE_dBCSPwd: val = "DRSUAPI_ATTRIBUTE_dBCSPwd"; break;
1389                         case DRSUAPI_ATTRIBUTE_logonHours: val = "DRSUAPI_ATTRIBUTE_logonHours"; break;
1390                         case DRSUAPI_ATTRIBUTE_userWorkstations: val = "DRSUAPI_ATTRIBUTE_userWorkstations"; break;
1391                         case DRSUAPI_ATTRIBUTE_unicodePwd: val = "DRSUAPI_ATTRIBUTE_unicodePwd"; break;
1392                         case DRSUAPI_ATTRIBUTE_ntPwdHistory: val = "DRSUAPI_ATTRIBUTE_ntPwdHistory"; break;
1393                         case DRSUAPI_ATTRIBUTE_priorValue: val = "DRSUAPI_ATTRIBUTE_priorValue"; break;
1394                         case DRSUAPI_ATTRIBUTE_supplementalCredentials: val = "DRSUAPI_ATTRIBUTE_supplementalCredentials"; break;
1395                         case DRSUAPI_ATTRIBUTE_trustAuthIncoming: val = "DRSUAPI_ATTRIBUTE_trustAuthIncoming"; break;
1396                         case DRSUAPI_ATTRIBUTE_trustAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_trustAuthOutgoing"; break;
1397                         case DRSUAPI_ATTRIBUTE_lmPwdHistory: val = "DRSUAPI_ATTRIBUTE_lmPwdHistory"; break;
1398                         case DRSUAPI_ATTRIBUTE_systemPossSuperiors: val = "DRSUAPI_ATTRIBUTE_systemPossSuperiors"; break;
1399                         case DRSUAPI_ATTRIBUTE_systemMayContain: val = "DRSUAPI_ATTRIBUTE_systemMayContain"; break;
1400                         case DRSUAPI_ATTRIBUTE_systemMustContain: val = "DRSUAPI_ATTRIBUTE_systemMustContain"; break;
1401                         case DRSUAPI_ATTRIBUTE_systemAuxiliaryClass: val = "DRSUAPI_ATTRIBUTE_systemAuxiliaryClass"; break;
1402                         case DRSUAPI_ATTRIBUTE_sAMAccountName: val = "DRSUAPI_ATTRIBUTE_sAMAccountName"; break;
1403                         case DRSUAPI_ATTRIBUTE_sAMAccountType: val = "DRSUAPI_ATTRIBUTE_sAMAccountType"; break;
1404                         case DRSUAPI_ATTRIBUTE_fSMORoleOwner: val = "DRSUAPI_ATTRIBUTE_fSMORoleOwner"; break;
1405                         case DRSUAPI_ATTRIBUTE_systemFlags: val = "DRSUAPI_ATTRIBUTE_systemFlags"; break;
1406                         case DRSUAPI_ATTRIBUTE_serverReference: val = "DRSUAPI_ATTRIBUTE_serverReference"; break;
1407                         case DRSUAPI_ATTRIBUTE_serverReferenceBL: val = "DRSUAPI_ATTRIBUTE_serverReferenceBL"; break;
1408                         case DRSUAPI_ATTRIBUTE_initialAuthIncoming: val = "DRSUAPI_ATTRIBUTE_initialAuthIncoming"; break;
1409                         case DRSUAPI_ATTRIBUTE_initialAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_initialAuthOutgoing"; break;
1410                         case DRSUAPI_ATTRIBUTE_wellKnownObjects: val = "DRSUAPI_ATTRIBUTE_wellKnownObjects"; break;
1411                         case DRSUAPI_ATTRIBUTE_dNSHostName: val = "DRSUAPI_ATTRIBUTE_dNSHostName"; break;
1412                         case DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet: val = "DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet"; break;
1413                         case DRSUAPI_ATTRIBUTE_userPrincipalName: val = "DRSUAPI_ATTRIBUTE_userPrincipalName"; break;
1414                         case DRSUAPI_ATTRIBUTE_groupType: val = "DRSUAPI_ATTRIBUTE_groupType"; break;
1415                         case DRSUAPI_ATTRIBUTE_servicePrincipalName: val = "DRSUAPI_ATTRIBUTE_servicePrincipalName"; break;
1416                         case DRSUAPI_ATTRIBUTE_objectCategory: val = "DRSUAPI_ATTRIBUTE_objectCategory"; break;
1417                         case DRSUAPI_ATTRIBUTE_gPLink: val = "DRSUAPI_ATTRIBUTE_gPLink"; break;
1418                         case DRSUAPI_ATTRIBUTE_transportAddressAttribute: val = "DRSUAPI_ATTRIBUTE_transportAddressAttribute"; break;
1419                         case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version: val = "DRSUAPI_ATTRIBUTE_msDS_Behavior_Version"; break;
1420                         case DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber: val = "DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber"; break;
1421                         case DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs: val = "DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs"; break;
1422                         case DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs"; break;
1423                         case DRSUAPI_ATTRIBUTE_NONE: val = "DRSUAPI_ATTRIBUTE_NONE"; break;
1424                 }
1425                 ndr_print_enum(ndr, name, "ENUM", val, r);
1426                 ndr->flags = _flags_save_ENUM;
1427         }
1428 }
1429
1430 static enum ndr_err_code ndr_push_drsuapi_DsPartialAttributeSet(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsPartialAttributeSet *r)
1431 {
1432         uint32_t cntr_attids_0;
1433         if (ndr_flags & NDR_SCALARS) {
1434                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attids));
1435                 NDR_CHECK(ndr_push_align(ndr, 4));
1436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
1437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
1439                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1440                         NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attids[cntr_attids_0]));
1441                 }
1442                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1443         }
1444         if (ndr_flags & NDR_BUFFERS) {
1445         }
1446         return NDR_ERR_SUCCESS;
1447 }
1448
1449 static enum ndr_err_code ndr_pull_drsuapi_DsPartialAttributeSet(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsPartialAttributeSet *r)
1450 {
1451         uint32_t cntr_attids_0;
1452         TALLOC_CTX *_mem_save_attids_0;
1453         if (ndr_flags & NDR_SCALARS) {
1454                 NDR_CHECK(ndr_pull_array_size(ndr, &r->attids));
1455                 NDR_CHECK(ndr_pull_align(ndr, 4));
1456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attids));
1459                 if (r->num_attids < 1 || r->num_attids > 0x100000) {
1460                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1461                 }
1462                 NDR_PULL_ALLOC_N(ndr, r->attids, ndr_get_array_size(ndr, &r->attids));
1463                 _mem_save_attids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1464                 NDR_PULL_SET_MEM_CTX(ndr, r->attids, 0);
1465                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1466                         NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attids[cntr_attids_0]));
1467                 }
1468                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attids_0, 0);
1469                 if (r->attids) {
1470                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attids, r->num_attids));
1471                 }
1472                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1473         }
1474         if (ndr_flags & NDR_BUFFERS) {
1475         }
1476         return NDR_ERR_SUCCESS;
1477 }
1478
1479 _PUBLIC_ void ndr_print_drsuapi_DsPartialAttributeSet(struct ndr_print *ndr, const char *name, const struct drsuapi_DsPartialAttributeSet *r)
1480 {
1481         uint32_t cntr_attids_0;
1482         ndr_print_struct(ndr, name, "drsuapi_DsPartialAttributeSet");
1483         ndr->depth++;
1484         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
1485         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1486         ndr_print_uint32(ndr, "num_attids", r->num_attids);
1487         ndr->print(ndr, "%s: ARRAY(%d)", "attids", (int)r->num_attids);
1488         ndr->depth++;
1489         for (cntr_attids_0=0;cntr_attids_0<r->num_attids;cntr_attids_0++) {
1490                 char *idx_0=NULL;
1491                 if (asprintf(&idx_0, "[%d]", cntr_attids_0) != -1) {
1492                         ndr_print_drsuapi_DsAttributeId(ndr, "attids", r->attids[cntr_attids_0]);
1493                         free(idx_0);
1494                 }
1495         }
1496         ndr->depth--;
1497         ndr->depth--;
1498 }
1499
1500 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest8(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest8 *r)
1501 {
1502         if (ndr_flags & NDR_SCALARS) {
1503                 NDR_CHECK(ndr_push_align(ndr, 8));
1504                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1505                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1506                 if (r->naming_context == NULL) {
1507                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1508                 }
1509                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1510                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1511                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1512                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
1513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1515                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1516                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1517                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1518                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1519                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1520                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1521         }
1522         if (ndr_flags & NDR_BUFFERS) {
1523                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1524                 if (r->uptodateness_vector) {
1525                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1526                 }
1527                 if (r->partial_attribute_set) {
1528                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1529                 }
1530                 if (r->partial_attribute_set_ex) {
1531                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1532                 }
1533                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1534         }
1535         return NDR_ERR_SUCCESS;
1536 }
1537
1538 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest8(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest8 *r)
1539 {
1540         uint32_t _ptr_naming_context;
1541         TALLOC_CTX *_mem_save_naming_context_0;
1542         uint32_t _ptr_uptodateness_vector;
1543         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1544         uint32_t _ptr_partial_attribute_set;
1545         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1546         uint32_t _ptr_partial_attribute_set_ex;
1547         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1548         if (ndr_flags & NDR_SCALARS) {
1549                 NDR_CHECK(ndr_pull_align(ndr, 8));
1550                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1551                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1552                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1553                 if (_ptr_naming_context) {
1554                         NDR_PULL_ALLOC(ndr, r->naming_context);
1555                 } else {
1556                         r->naming_context = NULL;
1557                 }
1558                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1559                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1560                 if (_ptr_uptodateness_vector) {
1561                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1562                 } else {
1563                         r->uptodateness_vector = NULL;
1564                 }
1565                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
1566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1568                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1569                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1570                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1571                 if (_ptr_partial_attribute_set) {
1572                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1573                 } else {
1574                         r->partial_attribute_set = NULL;
1575                 }
1576                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1577                 if (_ptr_partial_attribute_set_ex) {
1578                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1579                 } else {
1580                         r->partial_attribute_set_ex = NULL;
1581                 }
1582                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1583                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1584         }
1585         if (ndr_flags & NDR_BUFFERS) {
1586                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1587                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1588                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1589                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1590                 if (r->uptodateness_vector) {
1591                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1592                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1593                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1594                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1595                 }
1596                 if (r->partial_attribute_set) {
1597                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1598                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1599                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1600                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1601                 }
1602                 if (r->partial_attribute_set_ex) {
1603                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1604                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1605                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1606                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1607                 }
1608                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1609         }
1610         return NDR_ERR_SUCCESS;
1611 }
1612
1613 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest8(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest8 *r)
1614 {
1615         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest8");
1616         ndr->depth++;
1617         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1618         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1619         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1620         ndr->depth++;
1621         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1622         ndr->depth--;
1623         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1624         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1625         ndr->depth++;
1626         if (r->uptodateness_vector) {
1627                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1628         }
1629         ndr->depth--;
1630         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
1631         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1632         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1633         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1634         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1635         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1636         ndr->depth++;
1637         if (r->partial_attribute_set) {
1638                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1639         }
1640         ndr->depth--;
1641         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1642         ndr->depth++;
1643         if (r->partial_attribute_set_ex) {
1644                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1645         }
1646         ndr->depth--;
1647         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1648         ndr->depth--;
1649 }
1650
1651 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest10(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest10 *r)
1652 {
1653         if (ndr_flags & NDR_SCALARS) {
1654                 NDR_CHECK(ndr_push_align(ndr, 8));
1655                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1656                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1657                 if (r->naming_context == NULL) {
1658                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1659                 }
1660                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1661                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1662                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1663                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
1664                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1665                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1666                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1667                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1668                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1669                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1670                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_flags));
1672                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1673         }
1674         if (ndr_flags & NDR_BUFFERS) {
1675                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1676                 if (r->uptodateness_vector) {
1677                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1678                 }
1679                 if (r->partial_attribute_set) {
1680                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1681                 }
1682                 if (r->partial_attribute_set_ex) {
1683                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1684                 }
1685                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1686         }
1687         return NDR_ERR_SUCCESS;
1688 }
1689
1690 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest10(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest10 *r)
1691 {
1692         uint32_t _ptr_naming_context;
1693         TALLOC_CTX *_mem_save_naming_context_0;
1694         uint32_t _ptr_uptodateness_vector;
1695         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1696         uint32_t _ptr_partial_attribute_set;
1697         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1698         uint32_t _ptr_partial_attribute_set_ex;
1699         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1700         if (ndr_flags & NDR_SCALARS) {
1701                 NDR_CHECK(ndr_pull_align(ndr, 8));
1702                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1703                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1704                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1705                 if (_ptr_naming_context) {
1706                         NDR_PULL_ALLOC(ndr, r->naming_context);
1707                 } else {
1708                         r->naming_context = NULL;
1709                 }
1710                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1711                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1712                 if (_ptr_uptodateness_vector) {
1713                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1714                 } else {
1715                         r->uptodateness_vector = NULL;
1716                 }
1717                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
1718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1720                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1721                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1722                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1723                 if (_ptr_partial_attribute_set) {
1724                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1725                 } else {
1726                         r->partial_attribute_set = NULL;
1727                 }
1728                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1729                 if (_ptr_partial_attribute_set_ex) {
1730                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1731                 } else {
1732                         r->partial_attribute_set_ex = NULL;
1733                 }
1734                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1735                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_flags));
1736                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1737         }
1738         if (ndr_flags & NDR_BUFFERS) {
1739                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1740                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1741                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1743                 if (r->uptodateness_vector) {
1744                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1745                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1746                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1747                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1748                 }
1749                 if (r->partial_attribute_set) {
1750                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1751                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1752                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1753                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1754                 }
1755                 if (r->partial_attribute_set_ex) {
1756                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1757                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1758                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1759                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1760                 }
1761                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1762         }
1763         return NDR_ERR_SUCCESS;
1764 }
1765
1766 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest10(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest10 *r)
1767 {
1768         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest10");
1769         ndr->depth++;
1770         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1771         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1772         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1773         ndr->depth++;
1774         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1775         ndr->depth--;
1776         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1777         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1778         ndr->depth++;
1779         if (r->uptodateness_vector) {
1780                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1781         }
1782         ndr->depth--;
1783         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
1784         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1785         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1786         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1787         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1788         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1789         ndr->depth++;
1790         if (r->partial_attribute_set) {
1791                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1792         }
1793         ndr->depth--;
1794         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1795         ndr->depth++;
1796         if (r->partial_attribute_set_ex) {
1797                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1798         }
1799         ndr->depth--;
1800         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1801         ndr_print_uint32(ndr, "more_flags", r->more_flags);
1802         ndr->depth--;
1803 }
1804
1805 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesRequest *r)
1806 {
1807         if (ndr_flags & NDR_SCALARS) {
1808                 int level = ndr_push_get_switch_value(ndr, r);
1809                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
1810                 NDR_CHECK(ndr_push_union_align(ndr, 8));
1811                 switch (level) {
1812                         case 5: {
1813                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1814                         break; }
1815
1816                         case 8: {
1817                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1818                         break; }
1819
1820                         case 10: {
1821                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1822                         break; }
1823
1824                         default:
1825                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1826                 }
1827         }
1828         if (ndr_flags & NDR_BUFFERS) {
1829                 int level = ndr_push_get_switch_value(ndr, r);
1830                 switch (level) {
1831                         case 5:
1832                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1833                         break;
1834
1835                         case 8:
1836                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1837                         break;
1838
1839                         case 10:
1840                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1841                         break;
1842
1843                         default:
1844                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1845                 }
1846         }
1847         return NDR_ERR_SUCCESS;
1848 }
1849
1850 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesRequest *r)
1851 {
1852         int level;
1853         int32_t _level;
1854         level = ndr_pull_get_switch_value(ndr, r);
1855         if (ndr_flags & NDR_SCALARS) {
1856                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
1857                 if (_level != level) {
1858                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1859                 }
1860                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
1861                 switch (level) {
1862                         case 5: {
1863                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1864                         break; }
1865
1866                         case 8: {
1867                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1868                         break; }
1869
1870                         case 10: {
1871                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1872                         break; }
1873
1874                         default:
1875                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1876                 }
1877         }
1878         if (ndr_flags & NDR_BUFFERS) {
1879                 switch (level) {
1880                         case 5:
1881                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1882                         break;
1883
1884                         case 8:
1885                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1886                         break;
1887
1888                         case 10:
1889                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1890                         break;
1891
1892                         default:
1893                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1894                 }
1895         }
1896         return NDR_ERR_SUCCESS;
1897 }
1898
1899 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesRequest *r)
1900 {
1901         int level;
1902         level = ndr_print_get_switch_value(ndr, r);
1903         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesRequest");
1904         switch (level) {
1905                 case 5:
1906                         ndr_print_drsuapi_DsGetNCChangesRequest5(ndr, "req5", &r->req5);
1907                 break;
1908
1909                 case 8:
1910                         ndr_print_drsuapi_DsGetNCChangesRequest8(ndr, "req8", &r->req8);
1911                 break;
1912
1913                 case 10:
1914                         ndr_print_drsuapi_DsGetNCChangesRequest10(ndr, "req10", &r->req10);
1915                 break;
1916
1917                 default:
1918                         ndr_print_bad_level(ndr, name, level);
1919         }
1920 }
1921
1922 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2 *r)
1923 {
1924         if (ndr_flags & NDR_SCALARS) {
1925                 NDR_CHECK(ndr_push_align(ndr, 8));
1926                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1927                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
1928                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
1929                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1930         }
1931         if (ndr_flags & NDR_BUFFERS) {
1932         }
1933         return NDR_ERR_SUCCESS;
1934 }
1935
1936 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2 *r)
1937 {
1938         if (ndr_flags & NDR_SCALARS) {
1939                 NDR_CHECK(ndr_pull_align(ndr, 8));
1940                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1941                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
1942                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
1943                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1944         }
1945         if (ndr_flags & NDR_BUFFERS) {
1946         }
1947         return NDR_ERR_SUCCESS;
1948 }
1949
1950 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2 *r)
1951 {
1952         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2");
1953         ndr->depth++;
1954         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1955         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
1956         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
1957         ndr->depth--;
1958 }
1959
1960 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1961 {
1962         uint32_t cntr_cursors_0;
1963         if (ndr_flags & NDR_SCALARS) {
1964                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1965                 NDR_CHECK(ndr_push_align(ndr, 8));
1966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
1967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1970                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1971                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1972                 }
1973                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1974         }
1975         if (ndr_flags & NDR_BUFFERS) {
1976         }
1977         return NDR_ERR_SUCCESS;
1978 }
1979
1980 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2CtrEx *r)
1981 {
1982         uint32_t cntr_cursors_0;
1983         TALLOC_CTX *_mem_save_cursors_0;
1984         if (ndr_flags & NDR_SCALARS) {
1985                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
1986                 NDR_CHECK(ndr_pull_align(ndr, 8));
1987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1989                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1990                 if (r->count > 0x100000) {
1991                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1992                 }
1993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1994                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
1995                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
1996                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
1997                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1998                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1999                 }
2000                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
2001                 if (r->cursors) {
2002                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
2003                 }
2004                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2005         }
2006         if (ndr_flags & NDR_BUFFERS) {
2007         }
2008         return NDR_ERR_SUCCESS;
2009 }
2010
2011 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2CtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2CtrEx *r)
2012 {
2013         uint32_t cntr_cursors_0;
2014         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2CtrEx");
2015         ndr->depth++;
2016         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
2017         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
2018         ndr_print_uint32(ndr, "count", r->count);
2019         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
2020         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
2021         ndr->depth++;
2022         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
2023                 char *idx_0=NULL;
2024                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
2025                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
2026                         free(idx_0);
2027                 }
2028         }
2029         ndr->depth--;
2030         ndr->depth--;
2031 }
2032
2033 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValue(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValue *r)
2034 {
2035         if (ndr_flags & NDR_SCALARS) {
2036                 NDR_CHECK(ndr_push_align(ndr, 5));
2037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->blob, 0)));
2038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->blob));
2039                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2040         }
2041         if (ndr_flags & NDR_BUFFERS) {
2042                 if (r->blob) {
2043                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->blob));
2044                 }
2045         }
2046         return NDR_ERR_SUCCESS;
2047 }
2048
2049 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValue *r)
2050 {
2051         uint32_t _ptr_blob;
2052         TALLOC_CTX *_mem_save_blob_0;
2053         if (ndr_flags & NDR_SCALARS) {
2054                 NDR_CHECK(ndr_pull_align(ndr, 5));
2055                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2056                 if (r->__ndr_size > 10485760) {
2057                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2058                 }
2059                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_blob));
2060                 if (_ptr_blob) {
2061                         NDR_PULL_ALLOC(ndr, r->blob);
2062                 } else {
2063                         r->blob = NULL;
2064                 }
2065                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2066         }
2067         if (ndr_flags & NDR_BUFFERS) {
2068                 if (r->blob) {
2069                         _mem_save_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
2070                         NDR_PULL_SET_MEM_CTX(ndr, r->blob, 0);
2071                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->blob));
2072                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_blob_0, 0);
2073                 }
2074         }
2075         return NDR_ERR_SUCCESS;
2076 }
2077
2078 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValue(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValue *r)
2079 {
2080         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
2081         ndr->depth++;
2082         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_DATA_BLOB(0, r->blob, 0):r->__ndr_size);
2083         ndr_print_ptr(ndr, "blob", r->blob);
2084         ndr->depth++;
2085         if (r->blob) {
2086                 ndr_print_DATA_BLOB(ndr, "blob", *r->blob);
2087         }
2088         ndr->depth--;
2089         ndr->depth--;
2090 }
2091
2092 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValueCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValueCtr *r)
2093 {
2094         uint32_t cntr_values_1;
2095         if (ndr_flags & NDR_SCALARS) {
2096                 NDR_CHECK(ndr_push_align(ndr, 5));
2097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
2098                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->values));
2099                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2100         }
2101         if (ndr_flags & NDR_BUFFERS) {
2102                 if (r->values) {
2103                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_values));
2104                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2105                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2106                         }
2107                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2108                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2109                         }
2110                 }
2111         }
2112         return NDR_ERR_SUCCESS;
2113 }
2114
2115 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValueCtr *r)
2116 {
2117         uint32_t _ptr_values;
2118         uint32_t cntr_values_1;
2119         TALLOC_CTX *_mem_save_values_0;
2120         TALLOC_CTX *_mem_save_values_1;
2121         if (ndr_flags & NDR_SCALARS) {
2122                 NDR_CHECK(ndr_pull_align(ndr, 5));
2123                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_values));
2124                 if (r->num_values > 10485760) {
2125                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2126                 }
2127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_values));
2128                 if (_ptr_values) {
2129                         NDR_PULL_ALLOC(ndr, r->values);
2130                 } else {
2131                         r->values = NULL;
2132                 }
2133                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2134         }
2135         if (ndr_flags & NDR_BUFFERS) {
2136                 if (r->values) {
2137                         _mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
2138                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2139                         NDR_CHECK(ndr_pull_array_size(ndr, &r->values));
2140                         NDR_PULL_ALLOC_N(ndr, r->values, ndr_get_array_size(ndr, &r->values));
2141                         _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
2142                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2143                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2144                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2145                         }
2146                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2147                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2148                         }
2149                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
2150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_0, 0);
2151                 }
2152                 if (r->values) {
2153                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->values, r->num_values));
2154                 }
2155         }
2156         return NDR_ERR_SUCCESS;
2157 }
2158
2159 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValueCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValueCtr *r)
2160 {
2161         uint32_t cntr_values_1;
2162         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValueCtr");
2163         ndr->depth++;
2164         ndr_print_uint32(ndr, "num_values", r->num_values);
2165         ndr_print_ptr(ndr, "values", r->values);
2166         ndr->depth++;
2167         if (r->values) {
2168                 ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->num_values);
2169                 ndr->depth++;
2170                 for (cntr_values_1=0;cntr_values_1<r->num_values;cntr_values_1++) {
2171                         char *idx_1=NULL;
2172                         if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
2173                                 ndr_print_drsuapi_DsAttributeValue(ndr, "values", &r->values[cntr_values_1]);
2174                                 free(idx_1);
2175                         }
2176                 }
2177                 ndr->depth--;
2178         }
2179         ndr->depth--;
2180         ndr->depth--;
2181 }
2182
2183 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2184 {
2185         if (ndr_flags & NDR_SCALARS) {
2186                 NDR_CHECK(ndr_push_align(ndr, 4));
2187                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
2188                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2189                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2190                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2192                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2193                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2194         }
2195         if (ndr_flags & NDR_BUFFERS) {
2196                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2197         }
2198         return NDR_ERR_SUCCESS;
2199 }
2200
2201 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3 *r)
2202 {
2203         if (ndr_flags & NDR_SCALARS) {
2204                 NDR_CHECK(ndr_pull_align(ndr, 4));
2205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2207                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2208                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2209                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2210                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2211                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2212         }
2213         if (ndr_flags & NDR_BUFFERS) {
2214                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2215         }
2216         return NDR_ERR_SUCCESS;
2217 }
2218
2219 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2220 {
2221         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3");
2222         ndr->depth++;
2223         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);
2224         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);
2225         ndr_print_GUID(ndr, "guid", &r->guid);
2226         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2227         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2228         ndr_print_string(ndr, "dn", r->dn);
2229         ndr->depth--;
2230 }
2231
2232 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3(const struct drsuapi_DsReplicaObjectIdentifier3 *r, struct smb_iconv_convenience *ic, int flags)
2233 {
2234         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3, ic);
2235 }
2236
2237 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2238 {
2239         if (ndr_flags & NDR_SCALARS) {
2240                 NDR_CHECK(ndr_push_align(ndr, 4));
2241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(r, ndr->iconv_convenience, ndr->flags)));
2242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2243                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2244                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2246                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->binary.length + 4));
2248                 {
2249                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2251                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
2252                         ndr->flags = _flags_save_DATA_BLOB;
2253                 }
2254                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2255         }
2256         if (ndr_flags & NDR_BUFFERS) {
2257                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2258         }
2259         return NDR_ERR_SUCCESS;
2260 }
2261
2262 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2263 {
2264         if (ndr_flags & NDR_SCALARS) {
2265                 NDR_CHECK(ndr_pull_align(ndr, 4));
2266                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2268                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2269                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2270                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2271                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2272                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
2273                 {
2274                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2276                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
2277                         ndr->flags = _flags_save_DATA_BLOB;
2278                 }
2279                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2280         }
2281         if (ndr_flags & NDR_BUFFERS) {
2282                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2283         }
2284         return NDR_ERR_SUCCESS;
2285 }
2286
2287 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2288 {
2289         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3Binary");
2290         ndr->depth++;
2291         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);
2292         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);
2293         ndr_print_GUID(ndr, "guid", &r->guid);
2294         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2295         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2296         ndr_print_string(ndr, "dn", r->dn);
2297         ndr_print_uint32(ndr, "__ndr_size_binary", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->binary.length + 4:r->__ndr_size_binary);
2298         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
2299         ndr->depth--;
2300 }
2301
2302 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttribute *r)
2303 {
2304         if (ndr_flags & NDR_SCALARS) {
2305                 NDR_CHECK(ndr_push_align(ndr, 5));
2306                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2307                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2308                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2309         }
2310         if (ndr_flags & NDR_BUFFERS) {
2311                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2312         }
2313         return NDR_ERR_SUCCESS;
2314 }
2315
2316 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttribute *r)
2317 {
2318         if (ndr_flags & NDR_SCALARS) {
2319                 NDR_CHECK(ndr_pull_align(ndr, 5));
2320                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2321                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2322                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2323         }
2324         if (ndr_flags & NDR_BUFFERS) {
2325                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2326         }
2327         return NDR_ERR_SUCCESS;
2328 }
2329
2330 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttribute *r)
2331 {
2332         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttribute");
2333         ndr->depth++;
2334         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2335         ndr_print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr);
2336         ndr->depth--;
2337 }
2338
2339 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttributeCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttributeCtr *r)
2340 {
2341         uint32_t cntr_attributes_1;
2342         if (ndr_flags & NDR_SCALARS) {
2343                 NDR_CHECK(ndr_push_align(ndr, 5));
2344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2345                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
2346                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2347         }
2348         if (ndr_flags & NDR_BUFFERS) {
2349                 if (r->attributes) {
2350                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attributes));
2351                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2352                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2353                         }
2354                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2355                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2356                         }
2357                 }
2358         }
2359         return NDR_ERR_SUCCESS;
2360 }
2361
2362 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttributeCtr *r)
2363 {
2364         uint32_t _ptr_attributes;
2365         uint32_t cntr_attributes_1;
2366         TALLOC_CTX *_mem_save_attributes_0;
2367         TALLOC_CTX *_mem_save_attributes_1;
2368         if (ndr_flags & NDR_SCALARS) {
2369                 NDR_CHECK(ndr_pull_align(ndr, 5));
2370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attributes));
2371                 if (r->num_attributes > 1048576) {
2372                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2373                 }
2374                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
2375                 if (_ptr_attributes) {
2376                         NDR_PULL_ALLOC(ndr, r->attributes);
2377                 } else {
2378                         r->attributes = NULL;
2379                 }
2380                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2381         }
2382         if (ndr_flags & NDR_BUFFERS) {
2383                 if (r->attributes) {
2384                         _mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2385                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2386                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
2387                         NDR_PULL_ALLOC_N(ndr, r->attributes, ndr_get_array_size(ndr, &r->attributes));
2388                         _mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2389                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2390                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2391                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2392                         }
2393                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2394                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2395                         }
2396                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
2397                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);
2398                 }
2399                 if (r->attributes) {
2400                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->num_attributes));
2401                 }
2402         }
2403         return NDR_ERR_SUCCESS;
2404 }
2405
2406 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttributeCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttributeCtr *r)
2407 {
2408         uint32_t cntr_attributes_1;
2409         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttributeCtr");
2410         ndr->depth++;
2411         ndr_print_uint32(ndr, "num_attributes", r->num_attributes);
2412         ndr_print_ptr(ndr, "attributes", r->attributes);
2413         ndr->depth++;
2414         if (r->attributes) {
2415                 ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->num_attributes);
2416                 ndr->depth++;
2417                 for (cntr_attributes_1=0;cntr_attributes_1<r->num_attributes;cntr_attributes_1++) {
2418                         char *idx_1=NULL;
2419                         if (asprintf(&idx_1, "[%d]", cntr_attributes_1) != -1) {
2420                                 ndr_print_drsuapi_DsReplicaAttribute(ndr, "attributes", &r->attributes[cntr_attributes_1]);
2421                                 free(idx_1);
2422                         }
2423                 }
2424                 ndr->depth--;
2425         }
2426         ndr->depth--;
2427         ndr->depth--;
2428 }
2429
2430 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2431 {
2432         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2433         return NDR_ERR_SUCCESS;
2434 }
2435
2436 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2437 {
2438         uint32_t v;
2439         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2440         *r = v;
2441         return NDR_ERR_SUCCESS;
2442 }
2443
2444 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2445 {
2446         ndr_print_uint32(ndr, name, r);
2447         ndr->depth++;
2448         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER", DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER, r);
2449         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC", DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC, r);
2450         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY", DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY, r);
2451         ndr->depth--;
2452 }
2453
2454 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObject(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObject *r)
2455 {
2456         if (ndr_flags & NDR_SCALARS) {
2457                 NDR_CHECK(ndr_push_align(ndr, 5));
2458                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2459                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, r->flags));
2460                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2461                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2462         }
2463         if (ndr_flags & NDR_BUFFERS) {
2464                 if (r->identifier) {
2465                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2466                 }
2467                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2468         }
2469         return NDR_ERR_SUCCESS;
2470 }
2471
2472 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObject *r)
2473 {
2474         uint32_t _ptr_identifier;
2475         TALLOC_CTX *_mem_save_identifier_0;
2476         if (ndr_flags & NDR_SCALARS) {
2477                 NDR_CHECK(ndr_pull_align(ndr, 5));
2478                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2479                 if (_ptr_identifier) {
2480                         NDR_PULL_ALLOC(ndr, r->identifier);
2481                 } else {
2482                         r->identifier = NULL;
2483                 }
2484                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, &r->flags));
2485                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2486                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2487         }
2488         if (ndr_flags & NDR_BUFFERS) {
2489                 if (r->identifier) {
2490                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2491                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2492                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2493                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2494                 }
2495                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2496         }
2497         return NDR_ERR_SUCCESS;
2498 }
2499
2500 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObject(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObject *r)
2501 {
2502         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObject");
2503         ndr->depth++;
2504         ndr_print_ptr(ndr, "identifier", r->identifier);
2505         ndr->depth++;
2506         if (r->identifier) {
2507                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2508         }
2509         ndr->depth--;
2510         ndr_print_drsuapi_DsReplicaObjectFlags(ndr, "flags", r->flags);
2511         ndr_print_drsuapi_DsReplicaAttributeCtr(ndr, "attribute_ctr", &r->attribute_ctr);
2512         ndr->depth--;
2513 }
2514
2515 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaData *r)
2516 {
2517         if (ndr_flags & NDR_SCALARS) {
2518                 NDR_CHECK(ndr_push_align(ndr, 8));
2519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2520                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
2521                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2522                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
2523                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2524         }
2525         if (ndr_flags & NDR_BUFFERS) {
2526         }
2527         return NDR_ERR_SUCCESS;
2528 }
2529
2530 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaData *r)
2531 {
2532         if (ndr_flags & NDR_SCALARS) {
2533                 NDR_CHECK(ndr_pull_align(ndr, 8));
2534                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2535                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
2536                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2537                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
2538                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2539         }
2540         if (ndr_flags & NDR_BUFFERS) {
2541         }
2542         return NDR_ERR_SUCCESS;
2543 }
2544
2545 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaData *r)
2546 {
2547         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaData");
2548         ndr->depth++;
2549         ndr_print_uint32(ndr, "version", r->version);
2550         ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
2551         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
2552         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
2553         ndr->depth--;
2554 }
2555
2556 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaDataCtr *r)
2557 {
2558         uint32_t cntr_meta_data_0;
2559         if (ndr_flags & NDR_SCALARS) {
2560                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
2561                 NDR_CHECK(ndr_push_align(ndr, 8));
2562                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2563                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2564                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2565                 }
2566                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2567         }
2568         if (ndr_flags & NDR_BUFFERS) {
2569         }
2570         return NDR_ERR_SUCCESS;
2571 }
2572
2573 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaDataCtr *r)
2574 {
2575         uint32_t cntr_meta_data_0;
2576         TALLOC_CTX *_mem_save_meta_data_0;
2577         if (ndr_flags & NDR_SCALARS) {
2578                 NDR_CHECK(ndr_pull_array_size(ndr, &r->meta_data));
2579                 NDR_CHECK(ndr_pull_align(ndr, 8));
2580                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2581                 if (r->count > 1048576) {
2582                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2583                 }
2584                 NDR_PULL_ALLOC_N(ndr, r->meta_data, ndr_get_array_size(ndr, &r->meta_data));
2585                 _mem_save_meta_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2586                 NDR_PULL_SET_MEM_CTX(ndr, r->meta_data, 0);
2587                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2588                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2589                 }
2590                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_0, 0);
2591                 if (r->meta_data) {
2592                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->meta_data, r->count));
2593                 }
2594                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2595         }
2596         if (ndr_flags & NDR_BUFFERS) {
2597         }
2598         return NDR_ERR_SUCCESS;
2599 }
2600
2601 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaDataCtr *r)
2602 {
2603         uint32_t cntr_meta_data_0;
2604         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaDataCtr");
2605         ndr->depth++;
2606         ndr_print_uint32(ndr, "count", r->count);
2607         ndr->print(ndr, "%s: ARRAY(%d)", "meta_data", (int)r->count);
2608         ndr->depth++;
2609         for (cntr_meta_data_0=0;cntr_meta_data_0<r->count;cntr_meta_data_0++) {
2610                 char *idx_0=NULL;
2611                 if (asprintf(&idx_0, "[%d]", cntr_meta_data_0) != -1) {
2612                         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data[cntr_meta_data_0]);
2613                         free(idx_0);
2614                 }
2615         }
2616         ndr->depth--;
2617         ndr->depth--;
2618 }
2619
2620 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItemEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItemEx *r)
2621 {
2622         if (ndr_flags & NDR_SCALARS) {
2623                 NDR_CHECK(ndr_push_align(ndr, 5));
2624                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
2625                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_nc_prefix));
2627                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parent_object_guid));
2628                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->meta_data_ctr));
2629                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2630         }
2631         if (ndr_flags & NDR_BUFFERS) {
2632                 if (r->next_object) {
2633                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2634                 }
2635                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2636                 if (r->parent_object_guid) {
2637                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2638                 }
2639                 if (r->meta_data_ctr) {
2640                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2641                 }
2642         }
2643         return NDR_ERR_SUCCESS;
2644 }
2645
2646 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItemEx *r)
2647 {
2648         uint32_t _ptr_next_object;
2649         TALLOC_CTX *_mem_save_next_object_0;
2650         uint32_t _ptr_parent_object_guid;
2651         TALLOC_CTX *_mem_save_parent_object_guid_0;
2652         uint32_t _ptr_meta_data_ctr;
2653         TALLOC_CTX *_mem_save_meta_data_ctr_0;
2654         if (ndr_flags & NDR_SCALARS) {
2655                 NDR_CHECK(ndr_pull_align(ndr, 5));
2656                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
2657                 if (_ptr_next_object) {
2658                         NDR_PULL_ALLOC(ndr, r->next_object);
2659                 } else {
2660                         r->next_object = NULL;
2661                 }
2662                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2663                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_nc_prefix));
2664                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parent_object_guid));
2665                 if (_ptr_parent_object_guid) {
2666                         NDR_PULL_ALLOC(ndr, r->parent_object_guid);
2667                 } else {
2668                         r->parent_object_guid = NULL;
2669                 }
2670                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_meta_data_ctr));
2671                 if (_ptr_meta_data_ctr) {
2672                         NDR_PULL_ALLOC(ndr, r->meta_data_ctr);
2673                 } else {
2674                         r->meta_data_ctr = NULL;
2675                 }
2676                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2677         }
2678         if (ndr_flags & NDR_BUFFERS) {
2679                 if (r->next_object) {
2680                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2681                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
2682                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2683                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
2684                 }
2685                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2686                 if (r->parent_object_guid) {
2687                         _mem_save_parent_object_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2688                         NDR_PULL_SET_MEM_CTX(ndr, r->parent_object_guid, 0);
2689                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2690                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_object_guid_0, 0);
2691                 }
2692                 if (r->meta_data_ctr) {
2693                         _mem_save_meta_data_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2694                         NDR_PULL_SET_MEM_CTX(ndr, r->meta_data_ctr, 0);
2695                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2696                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_ctr_0, 0);
2697                 }
2698         }
2699         return NDR_ERR_SUCCESS;
2700 }
2701
2702 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1 *r)
2703 {
2704         if (ndr_flags & NDR_SCALARS) {
2705                 NDR_CHECK(ndr_push_align(ndr, 8));
2706                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2707                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2708                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2709                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2710                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2712                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2713                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55));
2716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2718                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2719         }
2720         if (ndr_flags & NDR_BUFFERS) {
2721                 if (r->naming_context) {
2722                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2723                 }
2724                 if (r->uptodateness_vector) {
2725                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2726                 }
2727                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2728                 if (r->first_object) {
2729                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2730                 }
2731         }
2732         return NDR_ERR_SUCCESS;
2733 }
2734
2735 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1 *r)
2736 {
2737         uint32_t _ptr_naming_context;
2738         TALLOC_CTX *_mem_save_naming_context_0;
2739         uint32_t _ptr_uptodateness_vector;
2740         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2741         uint32_t _ptr_first_object;
2742         TALLOC_CTX *_mem_save_first_object_0;
2743         if (ndr_flags & NDR_SCALARS) {
2744                 NDR_CHECK(ndr_pull_align(ndr, 8));
2745                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2746                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2747                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2748                 if (_ptr_naming_context) {
2749                         NDR_PULL_ALLOC(ndr, r->naming_context);
2750                 } else {
2751                         r->naming_context = NULL;
2752                 }
2753                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2754                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2755                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2756                 if (_ptr_uptodateness_vector) {
2757                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2758                 } else {
2759                         r->uptodateness_vector = NULL;
2760                 }
2761                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2762                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2765                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2766                 if (_ptr_first_object) {
2767                         NDR_PULL_ALLOC(ndr, r->first_object);
2768                 } else {
2769                         r->first_object = NULL;
2770                 }
2771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2772                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2773         }
2774         if (ndr_flags & NDR_BUFFERS) {
2775                 if (r->naming_context) {
2776                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2777                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2778                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2779                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2780                 }
2781                 if (r->uptodateness_vector) {
2782                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2783                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2784                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2785                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2786                 }
2787                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2788                 if (r->first_object) {
2789                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2790                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2791                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2792                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2793                 }
2794         }
2795         return NDR_ERR_SUCCESS;
2796 }
2797
2798 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1 *r)
2799 {
2800         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1");
2801         ndr->depth++;
2802         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2803         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2804         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2805         ndr->depth++;
2806         if (r->naming_context) {
2807                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2808         }
2809         ndr->depth--;
2810         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2811         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2812         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2813         ndr->depth++;
2814         if (r->uptodateness_vector) {
2815                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2816         }
2817         ndr->depth--;
2818         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2819         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2820         ndr_print_uint32(ndr, "object_count", r->object_count);
2821         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);
2822         ndr_print_ptr(ndr, "first_object", r->first_object);
2823         ndr->depth++;
2824         if (r->first_object) {
2825                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2826         }
2827         ndr->depth--;
2828         ndr_print_uint32(ndr, "more_data", r->more_data);
2829         ndr->depth--;
2830 }
2831
2832 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr1(const struct drsuapi_DsGetNCChangesCtr1 *r, struct smb_iconv_convenience *ic, int flags)
2833 {
2834         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr1, ic);
2835 }
2836
2837 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsLinkedAttributeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2838 {
2839         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2840         return NDR_ERR_SUCCESS;
2841 }
2842
2843 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsLinkedAttributeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2844 {
2845         uint32_t v;
2846         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2847         *r = v;
2848         return NDR_ERR_SUCCESS;
2849 }
2850
2851 _PUBLIC_ void ndr_print_drsuapi_DsLinkedAttributeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2852 {
2853         ndr_print_uint32(ndr, name, r);
2854         ndr->depth++;
2855         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE", DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE, r);
2856         ndr->depth--;
2857 }
2858
2859 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaLinkedAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaLinkedAttribute *r)
2860 {
2861         if (ndr_flags & NDR_SCALARS) {
2862                 NDR_CHECK(ndr_push_align(ndr, 8));
2863                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2864                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2865                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2866                 NDR_CHECK(ndr_push_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, r->flags));
2867                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_add_time));
2868                 NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2869                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2870         }
2871         if (ndr_flags & NDR_BUFFERS) {
2872                 if (r->identifier) {
2873                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2874                 }
2875                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2876         }
2877         return NDR_ERR_SUCCESS;
2878 }
2879
2880 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaLinkedAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaLinkedAttribute *r)
2881 {
2882         uint32_t _ptr_identifier;
2883         TALLOC_CTX *_mem_save_identifier_0;
2884         if (ndr_flags & NDR_SCALARS) {
2885                 NDR_CHECK(ndr_pull_align(ndr, 8));
2886                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2887                 if (_ptr_identifier) {
2888                         NDR_PULL_ALLOC(ndr, r->identifier);
2889                 } else {
2890                         r->identifier = NULL;
2891                 }
2892                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2893                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2894                 NDR_CHECK(ndr_pull_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, &r->flags));
2895                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_add_time));
2896                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2897                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2898         }
2899         if (ndr_flags & NDR_BUFFERS) {
2900                 if (r->identifier) {
2901                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2902                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2903                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2904                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2905                 }
2906                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2907         }
2908         return NDR_ERR_SUCCESS;
2909 }
2910
2911 _PUBLIC_ void ndr_print_drsuapi_DsReplicaLinkedAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaLinkedAttribute *r)
2912 {
2913         ndr_print_struct(ndr, name, "drsuapi_DsReplicaLinkedAttribute");
2914         ndr->depth++;
2915         ndr_print_ptr(ndr, "identifier", r->identifier);
2916         ndr->depth++;
2917         if (r->identifier) {
2918                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2919         }
2920         ndr->depth--;
2921         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2922         ndr_print_drsuapi_DsAttributeValue(ndr, "value", &r->value);
2923         ndr_print_drsuapi_DsLinkedAttributeFlags(ndr, "flags", r->flags);
2924         ndr_print_NTTIME_1sec(ndr, "originating_add_time", r->originating_add_time);
2925         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data);
2926         ndr->depth--;
2927 }
2928
2929 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6 *r)
2930 {
2931         uint32_t cntr_linked_attributes_1;
2932         if (ndr_flags & NDR_SCALARS) {
2933                 NDR_CHECK(ndr_push_align(ndr, 8));
2934                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2935                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2936                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2937                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2938                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2939                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2940                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2941                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2942                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55));
2944                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_object_count));
2947                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_linked_attributes_count));
2948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2949                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linked_attributes));
2950                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->drs_error));
2951                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2952         }
2953         if (ndr_flags & NDR_BUFFERS) {
2954                 if (r->naming_context) {
2955                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2956                 }
2957                 if (r->uptodateness_vector) {
2958                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2959                 }
2960                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2961                 if (r->first_object) {
2962                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2963                 }
2964                 if (r->linked_attributes) {
2965                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->linked_attributes_count));
2966                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2967                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2968                         }
2969                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2970                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
2971                         }
2972                 }
2973         }
2974         return NDR_ERR_SUCCESS;
2975 }
2976
2977 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6 *r)
2978 {
2979         uint32_t _ptr_naming_context;
2980         TALLOC_CTX *_mem_save_naming_context_0;
2981         uint32_t _ptr_uptodateness_vector;
2982         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2983         uint32_t _ptr_first_object;
2984         TALLOC_CTX *_mem_save_first_object_0;
2985         uint32_t _ptr_linked_attributes;
2986         uint32_t cntr_linked_attributes_1;
2987         TALLOC_CTX *_mem_save_linked_attributes_0;
2988         TALLOC_CTX *_mem_save_linked_attributes_1;
2989         if (ndr_flags & NDR_SCALARS) {
2990                 NDR_CHECK(ndr_pull_align(ndr, 8));
2991                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2992                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2993                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2994                 if (_ptr_naming_context) {
2995                         NDR_PULL_ALLOC(ndr, r->naming_context);
2996                 } else {
2997                         r->naming_context = NULL;
2998                 }
2999                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
3000                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
3001                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
3002                 if (_ptr_uptodateness_vector) {
3003                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
3004                 } else {
3005                         r->uptodateness_vector = NULL;
3006                 }
3007                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
3008                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
3009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
3010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
3011                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
3012                 if (_ptr_first_object) {
3013                         NDR_PULL_ALLOC(ndr, r->first_object);
3014                 } else {
3015                         r->first_object = NULL;
3016                 }
3017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
3018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_object_count));
3019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_linked_attributes_count));
3020                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linked_attributes_count));
3021                 if (r->linked_attributes_count > 1048576) {
3022                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3023                 }
3024                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linked_attributes));
3025                 if (_ptr_linked_attributes) {
3026                         NDR_PULL_ALLOC(ndr, r->linked_attributes);
3027                 } else {
3028                         r->linked_attributes = NULL;
3029                 }
3030                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->drs_error));
3031                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
3032         }
3033         if (ndr_flags & NDR_BUFFERS) {
3034                 if (r->naming_context) {
3035                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3036                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3037                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3038                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3039                 }
3040                 if (r->uptodateness_vector) {
3041                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
3042                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
3043                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
3044                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
3045                 }
3046                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
3047                 if (r->first_object) {
3048                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
3049                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
3050                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
3051                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
3052                 }
3053                 if (r->linked_attributes) {
3054                         _mem_save_linked_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
3055                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3056                         NDR_CHECK(ndr_pull_array_size(ndr, &r->linked_attributes));
3057                         NDR_PULL_ALLOC_N(ndr, r->linked_attributes, ndr_get_array_size(ndr, &r->linked_attributes));
3058                         _mem_save_linked_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
3059                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3060                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3061                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
3062                         }
3063                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3064                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
3065                         }
3066                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_1, 0);
3067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_0, 0);
3068                 }
3069                 if (r->linked_attributes) {
3070                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->linked_attributes, r->linked_attributes_count));
3071                 }
3072         }
3073         return NDR_ERR_SUCCESS;
3074 }
3075
3076 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6 *r)
3077 {
3078         uint32_t cntr_linked_attributes_1;
3079         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6");
3080         ndr->depth++;
3081         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
3082         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
3083         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3084         ndr->depth++;
3085         if (r->naming_context) {
3086                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3087         }
3088         ndr->depth--;
3089         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
3090         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
3091         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
3092         ndr->depth++;
3093         if (r->uptodateness_vector) {
3094                 ndr_print_drsuapi_DsReplicaCursor2CtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
3095         }
3096         ndr->depth--;
3097         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
3098         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
3099         ndr_print_uint32(ndr, "object_count", r->object_count);
3100         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);
3101         ndr_print_ptr(ndr, "first_object", r->first_object);
3102         ndr->depth++;
3103         if (r->first_object) {
3104                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
3105         }
3106         ndr->depth--;
3107         ndr_print_uint32(ndr, "more_data", r->more_data);
3108         ndr_print_uint32(ndr, "nc_object_count", r->nc_object_count);
3109         ndr_print_uint32(ndr, "nc_linked_attributes_count", r->nc_linked_attributes_count);
3110         ndr_print_uint32(ndr, "linked_attributes_count", r->linked_attributes_count);
3111         ndr_print_ptr(ndr, "linked_attributes", r->linked_attributes);
3112         ndr->depth++;
3113         if (r->linked_attributes) {
3114                 ndr->print(ndr, "%s: ARRAY(%d)", "linked_attributes", (int)r->linked_attributes_count);
3115                 ndr->depth++;
3116                 for (cntr_linked_attributes_1=0;cntr_linked_attributes_1<r->linked_attributes_count;cntr_linked_attributes_1++) {
3117                         char *idx_1=NULL;
3118                         if (asprintf(&idx_1, "[%d]", cntr_linked_attributes_1) != -1) {
3119                                 ndr_print_drsuapi_DsReplicaLinkedAttribute(ndr, "linked_attributes", &r->linked_attributes[cntr_linked_attributes_1]);
3120                                 free(idx_1);
3121                         }
3122                 }
3123                 ndr->depth--;
3124         }
3125         ndr->depth--;
3126         ndr_print_WERROR(ndr, "drs_error", r->drs_error);
3127         ndr->depth--;
3128 }
3129
3130 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr6(const struct drsuapi_DsGetNCChangesCtr6 *r, struct smb_iconv_convenience *ic, int flags)
3131 {
3132         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr6, ic);
3133 }
3134
3135 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3136 {
3137         if (ndr_flags & NDR_SCALARS) {
3138                 NDR_CHECK(ndr_push_align(ndr, 1));
3139                 {
3140                         struct ndr_push *_ndr_ctr1;
3141                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3142                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3143                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3144                 }
3145                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3146         }
3147         if (ndr_flags & NDR_BUFFERS) {
3148         }
3149         return NDR_ERR_SUCCESS;
3150 }
3151
3152 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1TS *r)
3153 {
3154         if (ndr_flags & NDR_SCALARS) {
3155                 NDR_CHECK(ndr_pull_align(ndr, 1));
3156                 {
3157                         struct ndr_pull *_ndr_ctr1;
3158                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3159                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3160                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3161                 }
3162                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3163         }
3164         if (ndr_flags & NDR_BUFFERS) {
3165         }
3166         return NDR_ERR_SUCCESS;
3167 }
3168
3169 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3170 {
3171         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1TS");
3172         ndr->depth++;
3173         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3174         ndr->depth--;
3175 }
3176
3177 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3178 {
3179         if (ndr_flags & NDR_SCALARS) {
3180                 NDR_CHECK(ndr_push_align(ndr, 1));
3181                 {
3182                         struct ndr_push *_ndr_ctr6;
3183                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3184                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3185                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3186                 }
3187                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3188         }
3189         if (ndr_flags & NDR_BUFFERS) {
3190         }
3191         return NDR_ERR_SUCCESS;
3192 }
3193
3194 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6TS *r)
3195 {
3196         if (ndr_flags & NDR_SCALARS) {
3197                 NDR_CHECK(ndr_pull_align(ndr, 1));
3198                 {
3199                         struct ndr_pull *_ndr_ctr6;
3200                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3201                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3202                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3203                 }
3204                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3205         }
3206         if (ndr_flags & NDR_BUFFERS) {
3207         }
3208         return NDR_ERR_SUCCESS;
3209 }
3210
3211 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3212 {
3213         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6TS");
3214         ndr->depth++;
3215         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3216         ndr->depth--;
3217 }
3218
3219 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3220 {
3221         uint32_t _ptr_ts;
3222         TALLOC_CTX *_mem_save_ts_0;
3223         if (ndr_flags & NDR_SCALARS) {
3224                 NDR_CHECK(ndr_pull_align(ndr, 5));
3225                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3226                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3227                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3228                 if (_ptr_ts) {
3229                         NDR_PULL_ALLOC(ndr, r->ts);
3230                 } else {
3231                         r->ts = NULL;
3232                 }
3233                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3234         }
3235         if (ndr_flags & NDR_BUFFERS) {
3236                 if (r->ts) {
3237                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3238                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3239                         {
3240                                 struct ndr_pull *_ndr_ts;
3241                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3242                                 {
3243                                         struct ndr_pull *_ndr_ts_compressed;
3244                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3245                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3246                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3247                                 }
3248                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3249                         }
3250                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3251                 }
3252         }
3253         return NDR_ERR_SUCCESS;
3254 }
3255
3256 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3257 {
3258         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr1");
3259         ndr->depth++;
3260         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3261         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3262         ndr_print_ptr(ndr, "ts", r->ts);
3263         ndr->depth++;
3264         if (r->ts) {
3265                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3266         }
3267         ndr->depth--;
3268         ndr->depth--;
3269 }
3270
3271 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3272 {
3273         uint32_t _ptr_ts;
3274         TALLOC_CTX *_mem_save_ts_0;
3275         if (ndr_flags & NDR_SCALARS) {
3276                 NDR_CHECK(ndr_pull_align(ndr, 5));
3277                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3279                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3280                 if (_ptr_ts) {
3281                         NDR_PULL_ALLOC(ndr, r->ts);
3282                 } else {
3283                         r->ts = NULL;
3284                 }
3285                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3286         }
3287         if (ndr_flags & NDR_BUFFERS) {
3288                 if (r->ts) {
3289                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3290                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3291                         {
3292                                 struct ndr_pull *_ndr_ts;
3293                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3294                                 {
3295                                         struct ndr_pull *_ndr_ts_compressed;
3296                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3297                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3298                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3299                                 }
3300                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3301                         }
3302                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3303                 }
3304         }
3305         return NDR_ERR_SUCCESS;
3306 }
3307
3308 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3309 {
3310         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr6");
3311         ndr->depth++;
3312         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3313         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3314         ndr_print_ptr(ndr, "ts", r->ts);
3315         ndr->depth++;
3316         if (r->ts) {
3317                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3318         }
3319         ndr->depth--;
3320         ndr->depth--;
3321 }
3322
3323 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3324 {
3325         uint32_t _ptr_ts;
3326         TALLOC_CTX *_mem_save_ts_0;
3327         if (ndr_flags & NDR_SCALARS) {
3328                 NDR_CHECK(ndr_pull_align(ndr, 5));
3329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3331                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3332                 if (_ptr_ts) {
3333                         NDR_PULL_ALLOC(ndr, r->ts);
3334                 } else {
3335                         r->ts = NULL;
3336                 }
3337                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3338         }
3339         if (ndr_flags & NDR_BUFFERS) {
3340                 if (r->ts) {
3341                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3342                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3343                         {
3344                                 struct ndr_pull *_ndr_ts;
3345                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3346                                 {
3347                                         struct ndr_pull *_ndr_ts_compressed;
3348                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3349                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3350                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3351                                 }
3352                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3353                         }
3354                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3355                 }
3356         }
3357         return NDR_ERR_SUCCESS;
3358 }
3359
3360 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3361 {
3362         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr1");
3363         ndr->depth++;
3364         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3365         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3366         ndr_print_ptr(ndr, "ts", r->ts);
3367         ndr->depth++;
3368         if (r->ts) {
3369                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3370         }
3371         ndr->depth--;
3372         ndr->depth--;
3373 }
3374
3375 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3376 {
3377         uint32_t _ptr_ts;
3378         TALLOC_CTX *_mem_save_ts_0;
3379         if (ndr_flags & NDR_SCALARS) {
3380                 NDR_CHECK(ndr_pull_align(ndr, 5));
3381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3382                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3383                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3384                 if (_ptr_ts) {
3385                         NDR_PULL_ALLOC(ndr, r->ts);
3386                 } else {
3387                         r->ts = NULL;
3388                 }
3389                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3390         }
3391         if (ndr_flags & NDR_BUFFERS) {
3392                 if (r->ts) {
3393                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3394                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3395                         {
3396                                 struct ndr_pull *_ndr_ts;
3397                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3398                                 {
3399                                         struct ndr_pull *_ndr_ts_compressed;
3400                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3401                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3402                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3403                                 }
3404                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3405                         }
3406                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3407                 }
3408         }
3409         return NDR_ERR_SUCCESS;
3410 }
3411
3412 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3413 {
3414         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr6");
3415         ndr->depth++;
3416         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3417         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3418         ndr_print_ptr(ndr, "ts", r->ts);
3419         ndr->depth++;
3420         if (r->ts) {
3421                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3422         }
3423         ndr->depth--;
3424         ndr->depth--;
3425 }
3426
3427 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressionType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType r)
3428 {
3429         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
3430         return NDR_ERR_SUCCESS;
3431 }
3432
3433 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressionType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType *r)
3434 {
3435         uint16_t v;
3436         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
3437         *r = v;
3438         return NDR_ERR_SUCCESS;
3439 }
3440
3441 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressionType(struct ndr_print *ndr, const char *name, enum drsuapi_DsGetNCChangesCompressionType r)
3442 {
3443         const char *val = NULL;
3444
3445         switch (r) {
3446                 case DRSUAPI_COMPRESSION_TYPE_MSZIP: val = "DRSUAPI_COMPRESSION_TYPE_MSZIP"; break;
3447                 case DRSUAPI_COMPRESSION_TYPE_XPRESS: val = "DRSUAPI_COMPRESSION_TYPE_XPRESS"; break;
3448         }
3449         ndr_print_enum(ndr, name, "ENUM", val, r);
3450 }
3451
3452 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3453 {
3454         {
3455                 uint32_t _flags_save_UNION = ndr->flags;
3456                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3457                 if (ndr_flags & NDR_SCALARS) {
3458                         int level = ndr_push_get_switch_value(ndr, r);
3459                         NDR_CHECK(ndr_push_union_align(ndr, 5));
3460                         switch (level) {
3461                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3462                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3463                                 break; }
3464
3465                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3466                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3467                                 break; }
3468
3469                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3470                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3471                                 break; }
3472
3473                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3474                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3475                                 break; }
3476
3477                                 default:
3478                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3479                         }
3480                 }
3481                 if (ndr_flags & NDR_BUFFERS) {
3482                         int level = ndr_push_get_switch_value(ndr, r);
3483                         switch (level) {
3484                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3485                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3486                                 break;
3487
3488                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3489                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3490                                 break;
3491
3492                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3493                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3494                                 break;
3495
3496                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3497                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3498                                 break;
3499
3500                                 default:
3501                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3502                         }
3503                 }
3504                 ndr->flags = _flags_save_UNION;
3505         }
3506         return NDR_ERR_SUCCESS;
3507 }
3508
3509 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCompressedCtr *r)
3510 {
3511         int level;
3512         {
3513                 uint32_t _flags_save_UNION = ndr->flags;
3514                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3515                 level = ndr_pull_get_switch_value(ndr, r);
3516                 if (ndr_flags & NDR_SCALARS) {
3517                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
3518                         switch (level) {
3519                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3520                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3521                                 break; }
3522
3523                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3524                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3525                                 break; }
3526
3527                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3528                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3529                                 break; }
3530
3531                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3532                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3533                                 break; }
3534
3535                                 default:
3536                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3537                         }
3538                 }
3539                 if (ndr_flags & NDR_BUFFERS) {
3540                         switch (level) {
3541                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3542                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3543                                 break;
3544
3545                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3546                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3547                                 break;
3548
3549                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3550                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3551                                 break;
3552
3553                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3554                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3555                                 break;
3556
3557                                 default:
3558                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3559                         }
3560                 }
3561                 ndr->flags = _flags_save_UNION;
3562         }
3563         return NDR_ERR_SUCCESS;
3564 }
3565
3566 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3567 {
3568         int level;
3569         {
3570                 uint32_t _flags_save_UNION = ndr->flags;
3571                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3572                 level = ndr_print_get_switch_value(ndr, r);
3573                 ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCompressedCtr");
3574                 switch (level) {
3575                         case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3576                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3577                         break;
3578
3579                         case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3580                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, "mszip6", &r->mszip6);
3581                         break;
3582
3583                         case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3584                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, "xpress1", &r->xpress1);
3585                         break;
3586
3587                         case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3588                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, "xpress6", &r->xpress6);
3589                         break;
3590
3591                         default:
3592                                 ndr_print_bad_level(ndr, name, level);
3593                 }
3594                 ndr->flags = _flags_save_UNION;
3595         }
3596 }
3597
3598 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr2 *r)
3599 {
3600         if (ndr_flags & NDR_SCALARS) {
3601                 NDR_CHECK(ndr_push_align(ndr, 5));
3602                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3603                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3604         }
3605         if (ndr_flags & NDR_BUFFERS) {
3606                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3607         }
3608         return NDR_ERR_SUCCESS;
3609 }
3610
3611 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr2 *r)
3612 {
3613         if (ndr_flags & NDR_SCALARS) {
3614                 NDR_CHECK(ndr_pull_align(ndr, 5));
3615                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3616                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3617         }
3618         if (ndr_flags & NDR_BUFFERS) {
3619                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3620         }
3621         return NDR_ERR_SUCCESS;
3622 }
3623
3624 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr2 *r)
3625 {
3626         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr2");
3627         ndr->depth++;
3628         ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3629         ndr->depth--;
3630 }
3631
3632 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr7 *r)
3633 {
3634         if (ndr_flags & NDR_SCALARS) {
3635                 NDR_CHECK(ndr_push_align(ndr, 5));
3636                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
3637                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, r->type));
3638                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3639                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3640                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3641         }
3642         if (ndr_flags & NDR_BUFFERS) {
3643                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3644         }
3645         return NDR_ERR_SUCCESS;
3646 }
3647
3648 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr7 *r)
3649 {
3650         if (ndr_flags & NDR_SCALARS) {
3651                 NDR_CHECK(ndr_pull_align(ndr, 5));
3652                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
3653                 if (r->level < 0 || r->level > 6) {
3654                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3655                 }
3656                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, &r->type));
3657                 if (r->type < 2 || r->type > 3) {
3658                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3659                 }
3660                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3661                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3662                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3663         }
3664         if (ndr_flags & NDR_BUFFERS) {
3665                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3666         }
3667         return NDR_ERR_SUCCESS;
3668 }
3669
3670 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr7(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr7 *r)
3671 {
3672         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr7");
3673         ndr->depth++;
3674         ndr_print_int32(ndr, "level", r->level);
3675         ndr_print_drsuapi_DsGetNCChangesCompressionType(ndr, "type", r->type);
3676         ndr_print_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16));
3677         ndr_print_drsuapi_DsGetNCChangesCompressedCtr(ndr, "ctr", &r->ctr);
3678         ndr->depth--;
3679 }
3680
3681 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCtr *r)
3682 {
3683         if (ndr_flags & NDR_SCALARS) {
3684                 int level = ndr_push_get_switch_value(ndr, r);
3685                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3686                 NDR_CHECK(ndr_push_union_align(ndr, 8));
3687                 switch (level) {
3688                         case 1: {
3689                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3690                         break; }
3691
3692                         case 2: {
3693                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3694                         break; }
3695
3696                         case 6: {
3697                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3698                         break; }
3699
3700                         case 7: {
3701                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3702                         break; }
3703
3704                         default:
3705                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3706                 }
3707         }
3708         if (ndr_flags & NDR_BUFFERS) {
3709                 int level = ndr_push_get_switch_value(ndr, r);
3710                 switch (level) {
3711                         case 1:
3712                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3713                         break;
3714
3715                         case 2:
3716                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3717                         break;
3718
3719                         case 6:
3720                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3721                         break;
3722
3723                         case 7:
3724                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3725                         break;
3726
3727                         default:
3728                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3729                 }
3730         }
3731         return NDR_ERR_SUCCESS;
3732 }
3733
3734 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCtr *r)
3735 {
3736         int level;
3737         int32_t _level;
3738         level = ndr_pull_get_switch_value(ndr, r);
3739         if (ndr_flags & NDR_SCALARS) {
3740                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3741                 if (_level != level) {
3742                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3743                 }
3744                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
3745                 switch (level) {
3746                         case 1: {
3747                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3748                         break; }
3749
3750                         case 2: {
3751                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3752                         break; }
3753
3754                         case 6: {
3755                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3756                         break; }
3757
3758                         case 7: {
3759                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3760                         break; }
3761
3762                         default:
3763                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3764                 }
3765         }
3766         if (ndr_flags & NDR_BUFFERS) {
3767                 switch (level) {
3768                         case 1:
3769                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3770                         break;
3771
3772                         case 2:
3773                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3774                         break;
3775
3776                         case 6:
3777                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3778                         break;
3779
3780                         case 7:
3781                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3782                         break;
3783
3784                         default:
3785                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3786                 }
3787         }
3788         return NDR_ERR_SUCCESS;
3789 }
3790
3791 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCtr *r)
3792 {
3793         int level;
3794         level = ndr_print_get_switch_value(ndr, r);
3795         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCtr");
3796         switch (level) {
3797                 case 1:
3798                         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3799                 break;
3800
3801                 case 2:
3802                         ndr_print_drsuapi_DsGetNCChangesCtr2(ndr, "ctr2", &r->ctr2);
3803                 break;
3804
3805                 case 6:
3806                         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3807                 break;
3808
3809                 case 7:
3810                         ndr_print_drsuapi_DsGetNCChangesCtr7(ndr, "ctr7", &r->ctr7);
3811                 break;
3812
3813                 default:
3814                         ndr_print_bad_level(ndr, name, level);
3815         }
3816 }
3817
3818 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3819 {
3820         if (ndr_flags & NDR_SCALARS) {
3821                 NDR_CHECK(ndr_push_align(ndr, 5));
3822                 if (r->naming_context == NULL) {
3823                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3824                 }
3825                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3826                 if (r->dest_dsa_dns_name == NULL) {
3827                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3828                 }
3829                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3830                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3831                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
3832                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3833         }
3834         if (ndr_flags & NDR_BUFFERS) {
3835                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3836                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3837                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3838                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3839                 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));
3840         }
3841         return NDR_ERR_SUCCESS;
3842 }
3843
3844 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3845 {
3846         uint32_t _ptr_naming_context;
3847         TALLOC_CTX *_mem_save_naming_context_0;
3848         uint32_t _ptr_dest_dsa_dns_name;
3849         if (ndr_flags & NDR_SCALARS) {
3850                 NDR_CHECK(ndr_pull_align(ndr, 5));
3851                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3852                 if (_ptr_naming_context) {
3853                         NDR_PULL_ALLOC(ndr, r->naming_context);
3854                 } else {
3855                         r->naming_context = NULL;
3856                 }
3857                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_dest_dsa_dns_name));
3858                 if (_ptr_dest_dsa_dns_name) {
3859                         NDR_PULL_ALLOC(ndr, r->dest_dsa_dns_name);
3860                 } else {
3861                         r->dest_dsa_dns_name = NULL;
3862                 }
3863                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3864                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
3865                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3866         }
3867         if (ndr_flags & NDR_BUFFERS) {
3868                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3869                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3870                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3871                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3872                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
3873                 NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
3874                 if (ndr_get_array_length(ndr, &r->dest_dsa_dns_name) > ndr_get_array_size(ndr, &r->dest_dsa_dns_name)) {
3875                         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));
3876                 }
3877                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t)));
3878                 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));
3879         }
3880         return NDR_ERR_SUCCESS;
3881 }
3882
3883 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3884 {
3885         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefsRequest1");
3886         ndr->depth++;
3887         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3888         ndr->depth++;
3889         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3890         ndr->depth--;
3891         ndr_print_ptr(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3892         ndr->depth++;
3893         ndr_print_string(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3894         ndr->depth--;
3895         ndr_print_GUID(ndr, "dest_dsa_guid", &r->dest_dsa_guid);
3896         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
3897         ndr->depth--;
3898 }
3899
3900 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3901 {
3902         if (ndr_flags & NDR_SCALARS) {
3903                 int level = ndr_push_get_switch_value(ndr, r);
3904                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3905                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3906                 switch (level) {
3907                         case 1: {
3908                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3909                         break; }
3910
3911                         default:
3912                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3913                 }
3914         }
3915         if (ndr_flags & NDR_BUFFERS) {
3916                 int level = ndr_push_get_switch_value(ndr, r);
3917                 switch (level) {
3918                         case 1:
3919                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3920                         break;
3921
3922                         default:
3923                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3924                 }
3925         }
3926         return NDR_ERR_SUCCESS;
3927 }
3928
3929 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaUpdateRefsRequest *r)
3930 {
3931         int level;
3932         int32_t _level;
3933         level = ndr_pull_get_switch_value(ndr, r);
3934         if (ndr_flags & NDR_SCALARS) {
3935                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3936                 if (_level != level) {
3937                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3938                 }
3939                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3940                 switch (level) {
3941                         case 1: {
3942                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3943                         break; }
3944
3945                         default:
3946                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3947                 }
3948         }
3949         if (ndr_flags & NDR_BUFFERS) {
3950                 switch (level) {
3951                         case 1:
3952                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3953                         break;
3954
3955                         default:
3956                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3957                 }
3958         }
3959         return NDR_ERR_SUCCESS;
3960 }
3961
3962 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3963 {
3964         int level;
3965         level = ndr_print_get_switch_value(ndr, r);
3966         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaUpdateRefsRequest");
3967         switch (level) {
3968                 case 1:
3969                         ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(ndr, "req1", &r->req1);
3970                 break;
3971
3972                 default:
3973                         ndr_print_bad_level(ndr, name, level);
3974         }
3975 }
3976
3977 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest1 *r)
3978 {
3979         if (ndr_flags & NDR_SCALARS) {
3980                 NDR_CHECK(ndr_push_align(ndr, 5));
3981                 if (r->naming_context == NULL) {
3982                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3983                 }
3984                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3985                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
3986                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
3987                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
3988                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3989         }
3990         if (ndr_flags & NDR_BUFFERS) {
3991                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3992                 if (r->source_dsa_address) {
3993                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3994                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3995                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3996                         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));
3997                 }
3998         }
3999         return NDR_ERR_SUCCESS;
4000 }
4001
4002 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest1 *r)
4003 {
4004         uint32_t _ptr_naming_context;
4005         TALLOC_CTX *_mem_save_naming_context_0;
4006         uint32_t _ptr_source_dsa_address;
4007         TALLOC_CTX *_mem_save_source_dsa_address_0;
4008         if (ndr_flags & NDR_SCALARS) {
4009                 NDR_CHECK(ndr_pull_align(ndr, 5));
4010                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4011                 if (_ptr_naming_context) {
4012                         NDR_PULL_ALLOC(ndr, r->naming_context);
4013                 } else {
4014                         r->naming_context = NULL;
4015                 }
4016                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4017                 if (_ptr_source_dsa_address) {
4018                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4019                 } else {
4020                         r->source_dsa_address = NULL;
4021                 }
4022                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4023                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4024                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4025         }
4026         if (ndr_flags & NDR_BUFFERS) {
4027                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4028                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4029                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4030                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4031                 if (r->source_dsa_address) {
4032                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4033                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4034                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4035                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4036                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4037                                 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));
4038                         }
4039                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4040                         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));
4041                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4042                 }
4043         }
4044         return NDR_ERR_SUCCESS;
4045 }
4046
4047 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest1 *r)
4048 {
4049         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest1");
4050         ndr->depth++;
4051         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4052         ndr->depth++;
4053         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4054         ndr->depth--;
4055         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4056         ndr->depth++;
4057         if (r->source_dsa_address) {
4058                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4059         }
4060         ndr->depth--;
4061         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4062         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4063         ndr->depth--;
4064 }
4065
4066 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest2 *r)
4067 {
4068         if (ndr_flags & NDR_SCALARS) {
4069                 NDR_CHECK(ndr_push_align(ndr, 5));
4070                 if (r->naming_context == NULL) {
4071                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4072                 }
4073                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4074                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_dn));
4075                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_dn));
4076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4077                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4078                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4079                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4080         }
4081         if (ndr_flags & NDR_BUFFERS) {
4082                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4083                 if (r->source_dsa_dn) {
4084                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4085                 }
4086                 if (r->transport_dn) {
4087                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4088                 }
4089                 if (r->source_dsa_address) {
4090                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4091                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4092                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4093                         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));
4094                 }
4095         }
4096         return NDR_ERR_SUCCESS;
4097 }
4098
4099 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest2 *r)
4100 {
4101         uint32_t _ptr_naming_context;
4102         TALLOC_CTX *_mem_save_naming_context_0;
4103         uint32_t _ptr_source_dsa_dn;
4104         TALLOC_CTX *_mem_save_source_dsa_dn_0;
4105         uint32_t _ptr_transport_dn;
4106         TALLOC_CTX *_mem_save_transport_dn_0;
4107         uint32_t _ptr_source_dsa_address;
4108         TALLOC_CTX *_mem_save_source_dsa_address_0;
4109         if (ndr_flags & NDR_SCALARS) {
4110                 NDR_CHECK(ndr_pull_align(ndr, 5));
4111                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4112                 if (_ptr_naming_context) {
4113                         NDR_PULL_ALLOC(ndr, r->naming_context);
4114                 } else {
4115                         r->naming_context = NULL;
4116                 }
4117                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_dn));
4118                 if (_ptr_source_dsa_dn) {
4119                         NDR_PULL_ALLOC(ndr, r->source_dsa_dn);
4120                 } else {
4121                         r->source_dsa_dn = NULL;
4122                 }
4123                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_dn));
4124                 if (_ptr_transport_dn) {
4125                         NDR_PULL_ALLOC(ndr, r->transport_dn);
4126                 } else {
4127                         r->transport_dn = NULL;
4128                 }
4129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4130                 if (_ptr_source_dsa_address) {
4131                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4132                 } else {
4133                         r->source_dsa_address = NULL;
4134                 }
4135                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4136                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4137                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4138         }
4139         if (ndr_flags & NDR_BUFFERS) {
4140                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4141                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4142                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4143                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4144                 if (r->source_dsa_dn) {
4145                         _mem_save_source_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4146                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_dn, 0);
4147                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4148                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_dn_0, 0);
4149                 }
4150                 if (r->transport_dn) {
4151                         _mem_save_transport_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4152                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_dn, 0);
4153                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4154                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_dn_0, 0);
4155                 }
4156                 if (r->source_dsa_address) {
4157                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4158                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4159                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4160                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4161                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4162                                 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));
4163                         }
4164                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4165                         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));
4166                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4167                 }
4168         }
4169         return NDR_ERR_SUCCESS;
4170 }
4171
4172 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest2 *r)
4173 {
4174         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest2");
4175         ndr->depth++;
4176         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4177         ndr->depth++;
4178         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4179         ndr->depth--;
4180         ndr_print_ptr(ndr, "source_dsa_dn", r->source_dsa_dn);
4181         ndr->depth++;
4182         if (r->source_dsa_dn) {
4183                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "source_dsa_dn", r->source_dsa_dn);
4184         }
4185         ndr->depth--;
4186         ndr_print_ptr(ndr, "transport_dn", r->transport_dn);
4187         ndr->depth++;
4188         if (r->transport_dn) {
4189                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "transport_dn", r->transport_dn);
4190         }
4191         ndr->depth--;
4192         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4193         ndr->depth++;
4194         if (r->source_dsa_address) {
4195                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4196         }
4197         ndr->depth--;
4198         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4199         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4200         ndr->depth--;
4201 }
4202
4203 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaAddRequest *r)
4204 {
4205         if (ndr_flags & NDR_SCALARS) {
4206                 int level = ndr_push_get_switch_value(ndr, r);
4207                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4208                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4209                 switch (level) {
4210                         case 1: {
4211                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4212                         break; }
4213
4214                         case 2: {
4215                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4216                         break; }
4217
4218                         default:
4219                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4220                 }
4221         }
4222         if (ndr_flags & NDR_BUFFERS) {
4223                 int level = ndr_push_get_switch_value(ndr, r);
4224                 switch (level) {
4225                         case 1:
4226                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4227                         break;
4228
4229                         case 2:
4230                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4231                         break;
4232
4233                         default:
4234                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4235                 }
4236         }
4237         return NDR_ERR_SUCCESS;
4238 }
4239
4240 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaAddRequest *r)
4241 {
4242         int level;
4243         int32_t _level;
4244         level = ndr_pull_get_switch_value(ndr, r);
4245         if (ndr_flags & NDR_SCALARS) {
4246                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4247                 if (_level != level) {
4248                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4249                 }
4250                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4251                 switch (level) {
4252                         case 1: {
4253                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4254                         break; }
4255
4256                         case 2: {
4257                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4258                         break; }
4259
4260                         default:
4261                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4262                 }
4263         }
4264         if (ndr_flags & NDR_BUFFERS) {
4265                 switch (level) {
4266                         case 1:
4267                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4268                         break;
4269
4270                         case 2:
4271                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4272                         break;
4273
4274                         default:
4275                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4276                 }
4277         }
4278         return NDR_ERR_SUCCESS;
4279 }
4280
4281 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaAddRequest *r)
4282 {
4283         int level;
4284         level = ndr_print_get_switch_value(ndr, r);
4285         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaAddRequest");
4286         switch (level) {
4287                 case 1:
4288                         ndr_print_drsuapi_DsReplicaAddRequest1(ndr, "req1", &r->req1);
4289                 break;
4290
4291                 case 2:
4292                         ndr_print_drsuapi_DsReplicaAddRequest2(ndr, "req2", &r->req2);
4293                 break;
4294
4295                 default:
4296                         ndr_print_bad_level(ndr, name, level);
4297         }
4298 }
4299
4300 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaDelRequest1 *r)
4301 {
4302         if (ndr_flags & NDR_SCALARS) {
4303                 NDR_CHECK(ndr_push_align(ndr, 5));
4304                 if (r->naming_context == NULL) {
4305                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4306                 }
4307                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4308                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4309                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4310                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4311         }
4312         if (ndr_flags & NDR_BUFFERS) {
4313                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4314                 if (r->source_dsa_address) {
4315                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4316                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4317                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4318                         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));
4319                 }
4320         }
4321         return NDR_ERR_SUCCESS;
4322 }
4323
4324 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaDelRequest1 *r)
4325 {
4326         uint32_t _ptr_naming_context;
4327         TALLOC_CTX *_mem_save_naming_context_0;
4328         uint32_t _ptr_source_dsa_address;
4329         TALLOC_CTX *_mem_save_source_dsa_address_0;
4330         if (ndr_flags & NDR_SCALARS) {
4331                 NDR_CHECK(ndr_pull_align(ndr, 5));
4332                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4333                 if (_ptr_naming_context) {
4334                         NDR_PULL_ALLOC(ndr, r->naming_context);
4335                 } else {
4336                         r->naming_context = NULL;
4337                 }
4338                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4339                 if (_ptr_source_dsa_address) {
4340                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4341                 } else {
4342                         r->source_dsa_address = NULL;
4343                 }
4344                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4345                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4346         }
4347         if (ndr_flags & NDR_BUFFERS) {
4348                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4349                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4350                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4351                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4352                 if (r->source_dsa_address) {
4353                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4354                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4355                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4356                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4357                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4358                                 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));
4359                         }
4360                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4361                         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));
4362                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4363                 }
4364         }
4365         return NDR_ERR_SUCCESS;
4366 }
4367
4368 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaDelRequest1 *r)
4369 {
4370         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDelRequest1");
4371         ndr->depth++;
4372         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4373         ndr->depth++;
4374         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4375         ndr->depth--;
4376         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4377         ndr->depth++;
4378         if (r->source_dsa_address) {
4379                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4380         }
4381         ndr->depth--;
4382         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4383         ndr->depth--;
4384 }
4385
4386 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaDelRequest *r)
4387 {
4388         if (ndr_flags & NDR_SCALARS) {
4389                 int level = ndr_push_get_switch_value(ndr, r);
4390                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4391                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4392                 switch (level) {
4393                         case 1: {
4394                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4395                         break; }
4396
4397                         default:
4398                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4399                 }
4400         }
4401         if (ndr_flags & NDR_BUFFERS) {
4402                 int level = ndr_push_get_switch_value(ndr, r);
4403                 switch (level) {
4404                         case 1:
4405                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4406                         break;
4407
4408                         default:
4409                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4410                 }
4411         }
4412         return NDR_ERR_SUCCESS;
4413 }
4414
4415 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaDelRequest *r)
4416 {
4417         int level;
4418         int32_t _level;
4419         level = ndr_pull_get_switch_value(ndr, r);
4420         if (ndr_flags & NDR_SCALARS) {
4421                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4422                 if (_level != level) {
4423                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4424                 }
4425                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4426                 switch (level) {
4427                         case 1: {
4428                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4429                         break; }
4430
4431                         default:
4432                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4433                 }
4434         }
4435         if (ndr_flags & NDR_BUFFERS) {
4436                 switch (level) {
4437                         case 1:
4438                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4439                         break;
4440
4441                         default:
4442                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4443                 }
4444         }
4445         return NDR_ERR_SUCCESS;
4446 }
4447
4448 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaDelRequest *r)
4449 {
4450         int level;
4451         level = ndr_print_get_switch_value(ndr, r);
4452         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaDelRequest");
4453         switch (level) {
4454                 case 1:
4455                         ndr_print_drsuapi_DsReplicaDelRequest1(ndr, "req1", &r->req1);
4456                 break;
4457
4458                 default:
4459                         ndr_print_bad_level(ndr, name, level);
4460         }
4461 }
4462
4463 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaModRequest1 *r)
4464 {
4465         if (ndr_flags & NDR_SCALARS) {
4466                 NDR_CHECK(ndr_push_align(ndr, 5));
4467                 if (r->naming_context == NULL) {
4468                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4469                 }
4470                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4471                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dra));
4472                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dra_address));
4473                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->replica_flags));
4475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->modify_fields));
4476                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4477                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4478         }
4479         if (ndr_flags & NDR_BUFFERS) {
4480                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4481                 if (r->source_dra_address) {
4482                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4483                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4484                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4485                         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));
4486                 }
4487         }
4488         return NDR_ERR_SUCCESS;
4489 }
4490
4491 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaModRequest1 *r)
4492 {
4493         uint32_t _ptr_naming_context;
4494         TALLOC_CTX *_mem_save_naming_context_0;
4495         uint32_t _ptr_source_dra_address;
4496         TALLOC_CTX *_mem_save_source_dra_address_0;
4497         if (ndr_flags & NDR_SCALARS) {
4498                 NDR_CHECK(ndr_pull_align(ndr, 5));
4499                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4500                 if (_ptr_naming_context) {
4501                         NDR_PULL_ALLOC(ndr, r->naming_context);
4502                 } else {
4503                         r->naming_context = NULL;
4504                 }
4505                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dra));
4506                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dra_address));
4507                 if (_ptr_source_dra_address) {
4508                         NDR_PULL_ALLOC(ndr, r->source_dra_address);
4509                 } else {
4510                         r->source_dra_address = NULL;
4511                 }
4512                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4513                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->replica_flags));
4514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->modify_fields));
4515                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4516                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4517         }
4518         if (ndr_flags & NDR_BUFFERS) {
4519                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4520                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4521                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4522                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4523                 if (r->source_dra_address) {
4524                         _mem_save_source_dra_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4525                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dra_address, 0);
4526                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dra_address));
4527                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dra_address));
4528                         if (ndr_get_array_length(ndr, &r->source_dra_address) > ndr_get_array_size(ndr, &r->source_dra_address)) {
4529                                 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));
4530                         }
4531                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t)));
4532                         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));
4533                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dra_address_0, 0);
4534                 }
4535         }
4536         return NDR_ERR_SUCCESS;
4537 }
4538
4539 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaModRequest1 *r)
4540 {
4541         ndr_print_struct(ndr, name, "drsuapi_DsReplicaModRequest1");
4542         ndr->depth++;
4543         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4544         ndr->depth++;
4545         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4546         ndr->depth--;
4547         ndr_print_GUID(ndr, "source_dra", &r->source_dra);
4548         ndr_print_ptr(ndr, "source_dra_address", r->source_dra_address);
4549         ndr->depth++;
4550         if (r->source_dra_address) {
4551                 ndr_print_string(ndr, "source_dra_address", r->source_dra_address);
4552         }
4553         ndr->depth--;
4554         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4555         ndr_print_uint32(ndr, "replica_flags", r->replica_flags);
4556         ndr_print_uint32(ndr, "modify_fields", r->modify_fields);
4557         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4558         ndr->depth--;
4559 }
4560
4561 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaModRequest *r)
4562 {
4563         if (ndr_flags & NDR_SCALARS) {
4564                 int level = ndr_push_get_switch_value(ndr, r);
4565                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4566                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4567                 switch (level) {
4568                         case 1: {
4569                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4570                         break; }
4571
4572                         default:
4573                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4574                 }
4575         }
4576         if (ndr_flags & NDR_BUFFERS) {
4577                 int level = ndr_push_get_switch_value(ndr, r);
4578                 switch (level) {
4579                         case 1:
4580                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4581                         break;
4582
4583                         default:
4584                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4585                 }
4586         }
4587         return NDR_ERR_SUCCESS;
4588 }
4589
4590 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaModRequest *r)
4591 {
4592         int level;
4593         int32_t _level;
4594         level = ndr_pull_get_switch_value(ndr, r);
4595         if (ndr_flags & NDR_SCALARS) {
4596                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4597                 if (_level != level) {
4598                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4599                 }
4600                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4601                 switch (level) {
4602                         case 1: {
4603                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4604                         break; }
4605
4606                         default:
4607                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4608                 }
4609         }
4610         if (ndr_flags & NDR_BUFFERS) {
4611                 switch (level) {
4612                         case 1:
4613                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4614                         break;
4615
4616                         default:
4617                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4618                 }
4619         }
4620         return NDR_ERR_SUCCESS;
4621 }
4622
4623 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaModRequest *r)
4624 {
4625         int level;
4626         level = ndr_print_get_switch_value(ndr, r);
4627         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaModRequest");
4628         switch (level) {
4629                 case 1:
4630                         ndr_print_drsuapi_DsReplicaModRequest1(ndr, "req1", &r->req1);
4631                 break;
4632
4633                 default:
4634                         ndr_print_bad_level(ndr, name, level);
4635         }
4636 }
4637
4638 static enum ndr_err_code ndr_push_drsuapi_DsMembershipType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsMembershipType r)
4639 {
4640         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
4641         return NDR_ERR_SUCCESS;
4642 }
4643
4644 static enum ndr_err_code ndr_pull_drsuapi_DsMembershipType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsMembershipType *r)
4645 {
4646         uint32_t v;
4647         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
4648         *r = v;
4649         return NDR_ERR_SUCCESS;
4650 }
4651
4652 _PUBLIC_ void ndr_print_drsuapi_DsMembershipType(struct ndr_print *ndr, const char *name, enum drsuapi_DsMembershipType r)
4653 {
4654         const char *val = NULL;
4655
4656         switch (r) {
4657                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS"; break;
4658                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS"; break;
4659                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS"; break;
4660                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2"; break;
4661                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS"; break;
4662                 case DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS"; break;
4663                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2"; break;
4664         }
4665         ndr_print_enum(ndr, name, "ENUM", val, r);
4666 }
4667
4668 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsCtr1 *r)
4669 {
4670         uint32_t cntr_info_array_1;
4671         uint32_t cntr_group_attrs_1;
4672         uint32_t cntr_sids_1;
4673         if (ndr_flags & NDR_SCALARS) {
4674                 NDR_CHECK(ndr_push_align(ndr, 5));
4675                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
4676                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
4677                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
4678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_attrs));
4680                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
4681                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4682         }
4683         if (ndr_flags & NDR_BUFFERS) {
4684                 if (r->info_array) {
4685                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4686                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4687                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4688                         }
4689                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4690                                 if (r->info_array[cntr_info_array_1]) {
4691                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4692                                 }
4693                         }
4694                 }
4695                 if (r->group_attrs) {
4696                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4697                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4698                                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->group_attrs[cntr_group_attrs_1]));
4699                         }
4700                 }
4701                 if (r->sids) {
4702                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_sids));
4703                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4704                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_1]));
4705                         }
4706                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4707                                 if (r->sids[cntr_sids_1]) {
4708                                         NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4709                                 }
4710                         }
4711                 }
4712         }
4713         return NDR_ERR_SUCCESS;
4714 }
4715
4716 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsCtr1 *r)
4717 {
4718         uint32_t _ptr_info_array;
4719         uint32_t cntr_info_array_1;
4720         TALLOC_CTX *_mem_save_info_array_0;
4721         TALLOC_CTX *_mem_save_info_array_1;
4722         TALLOC_CTX *_mem_save_info_array_2;
4723         uint32_t _ptr_group_attrs;
4724         uint32_t cntr_group_attrs_1;
4725         TALLOC_CTX *_mem_save_group_attrs_0;
4726         TALLOC_CTX *_mem_save_group_attrs_1;
4727         uint32_t _ptr_sids;
4728         uint32_t cntr_sids_1;
4729         TALLOC_CTX *_mem_save_sids_0;
4730         TALLOC_CTX *_mem_save_sids_1;
4731         TALLOC_CTX *_mem_save_sids_2;
4732         if (ndr_flags & NDR_SCALARS) {
4733                 NDR_CHECK(ndr_pull_align(ndr, 5));
4734                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
4735                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_memberships));
4736                 if (r->num_memberships > 10000) {
4737                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4738                 }
4739                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
4740                 if (r->num_sids > 10000) {
4741                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4742                 }
4743                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4744                 if (_ptr_info_array) {
4745                         NDR_PULL_ALLOC(ndr, r->info_array);
4746                 } else {
4747                         r->info_array = NULL;
4748                 }
4749                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_attrs));
4750                 if (_ptr_group_attrs) {
4751                         NDR_PULL_ALLOC(ndr, r->group_attrs);
4752                 } else {
4753                         r->group_attrs = NULL;
4754                 }
4755                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4756                 if (_ptr_sids) {
4757                         NDR_PULL_ALLOC(ndr, r->sids);
4758                 } else {
4759                         r->sids = NULL;
4760                 }
4761                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4762         }
4763         if (ndr_flags & NDR_BUFFERS) {
4764                 if (r->info_array) {
4765                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4766                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4767                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4768                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
4769                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4770                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4771                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4772                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4773                                 if (_ptr_info_array) {
4774                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4775                                 } else {
4776                                         r->info_array[cntr_info_array_1] = NULL;
4777                                 }
4778                         }
4779                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4780                                 if (r->info_array[cntr_info_array_1]) {
4781                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4782                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4783                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4784                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
4785                                 }
4786                         }
4787                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
4788                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
4789                 }
4790                 if (r->group_attrs) {
4791                         _mem_save_group_attrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
4792                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4793                         NDR_CHECK(ndr_pull_array_size(ndr, &r->group_attrs));
4794                         NDR_PULL_ALLOC_N(ndr, r->group_attrs, ndr_get_array_size(ndr, &r->group_attrs));
4795                         _mem_save_group_attrs_1 = NDR_PULL_GET_MEM_CTX(ndr);
4796                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4797                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4798                                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->group_attrs[cntr_group_attrs_1]));
4799                         }
4800                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_1, 0);
4801                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_0, 0);
4802                 }
4803                 if (r->sids) {
4804                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4805                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4806                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4807                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4808                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4809                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4810                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4811                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4812                                 if (_ptr_sids) {
4813                                         NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_1]);
4814                                 } else {
4815                                         r->sids[cntr_sids_1] = NULL;
4816                                 }
4817                         }
4818                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4819                                 if (r->sids[cntr_sids_1]) {
4820                                         _mem_save_sids_2 = NDR_PULL_GET_MEM_CTX(ndr);
4821                                         NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_1], 0);
4822                                         NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4823                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_2, 0);
4824                                 }
4825                         }
4826                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
4827                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
4828                 }
4829                 if (r->info_array) {
4830                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->num_memberships));
4831                 }
4832                 if (r->group_attrs) {
4833                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->group_attrs, r->num_memberships));
4834                 }
4835                 if (r->sids) {
4836                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
4837                 }
4838         }
4839         return NDR_ERR_SUCCESS;
4840 }
4841
4842 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsCtr1 *r)
4843 {
4844         uint32_t cntr_info_array_1;
4845         uint32_t cntr_group_attrs_1;
4846         uint32_t cntr_sids_1;
4847         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsCtr1");
4848         ndr->depth++;
4849         ndr_print_NTSTATUS(ndr, "status", r->status);
4850         ndr_print_uint32(ndr, "num_memberships", r->num_memberships);
4851         ndr_print_uint32(ndr, "num_sids", r->num_sids);
4852         ndr_print_ptr(ndr, "info_array", r->info_array);
4853         ndr->depth++;
4854         if (r->info_array) {
4855                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->num_memberships);
4856                 ndr->depth++;
4857                 for (cntr_info_array_1=0;cntr_info_array_1<r->num_memberships;cntr_info_array_1++) {
4858                         char *idx_1=NULL;
4859                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
4860                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
4861                                 ndr->depth++;
4862                                 if (r->info_array[cntr_info_array_1]) {
4863                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
4864                                 }
4865                                 ndr->depth--;
4866                                 free(idx_1);
4867                         }
4868                 }
4869                 ndr->depth--;
4870         }
4871         ndr->depth--;
4872         ndr_print_ptr(ndr, "group_attrs", r->group_attrs);
4873         ndr->depth++;
4874         if (r->group_attrs) {
4875                 ndr->print(ndr, "%s: ARRAY(%d)", "group_attrs", (int)r->num_memberships);
4876                 ndr->depth++;
4877                 for (cntr_group_attrs_1=0;cntr_group_attrs_1<r->num_memberships;cntr_group_attrs_1++) {
4878                         char *idx_1=NULL;
4879                         if (asprintf(&idx_1, "[%d]", cntr_group_attrs_1) != -1) {
4880                                 ndr_print_samr_GroupAttrs(ndr, "group_attrs", r->group_attrs[cntr_group_attrs_1]);
4881                                 free(idx_1);
4882                         }
4883                 }
4884                 ndr->depth--;
4885         }
4886         ndr->depth--;
4887         ndr_print_ptr(ndr, "sids", r->sids);
4888         ndr->depth++;
4889         if (r->sids) {
4890                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
4891                 ndr->depth++;
4892                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
4893                         char *idx_1=NULL;
4894                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4895                                 ndr_print_ptr(ndr, "sids", r->sids[cntr_sids_1]);
4896                                 ndr->depth++;
4897                                 if (r->sids[cntr_sids_1]) {
4898                                         ndr_print_dom_sid28(ndr, "sids", r->sids[cntr_sids_1]);
4899                                 }
4900                                 ndr->depth--;
4901                                 free(idx_1);
4902                         }
4903                 }
4904                 ndr->depth--;
4905         }
4906         ndr->depth--;
4907         ndr->depth--;
4908 }
4909
4910 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsCtr *r)
4911 {
4912         if (ndr_flags & NDR_SCALARS) {
4913                 int level = ndr_push_get_switch_value(ndr, r);
4914                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4915                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4916                 switch (level) {
4917                         case 1: {
4918                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4919                         break; }
4920
4921                         default:
4922                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4923                 }
4924         }
4925         if (ndr_flags & NDR_BUFFERS) {
4926                 int level = ndr_push_get_switch_value(ndr, r);
4927                 switch (level) {
4928                         case 1:
4929                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4930                         break;
4931
4932                         default:
4933                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4934                 }
4935         }
4936         return NDR_ERR_SUCCESS;
4937 }
4938
4939 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsCtr *r)
4940 {
4941         int level;
4942         int32_t _level;
4943         level = ndr_pull_get_switch_value(ndr, r);
4944         if (ndr_flags & NDR_SCALARS) {
4945                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4946                 if (_level != level) {
4947                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4948                 }
4949                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4950                 switch (level) {
4951                         case 1: {
4952                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4953                         break; }
4954
4955                         default:
4956                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4957                 }
4958         }
4959         if (ndr_flags & NDR_BUFFERS) {
4960                 switch (level) {
4961                         case 1:
4962                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4963                         break;
4964
4965                         default:
4966                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4967                 }
4968         }
4969         return NDR_ERR_SUCCESS;
4970 }
4971
4972 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsCtr *r)
4973 {
4974         int level;
4975         level = ndr_print_get_switch_value(ndr, r);
4976         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsCtr");
4977         switch (level) {
4978                 case 1:
4979                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
4980                 break;
4981
4982                 default:
4983                         ndr_print_bad_level(ndr, name, level);
4984         }
4985 }
4986
4987 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsRequest1 *r)
4988 {
4989         uint32_t cntr_info_array_1;
4990         if (ndr_flags & NDR_SCALARS) {
4991                 NDR_CHECK(ndr_push_align(ndr, 5));
4992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4993                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
4995                 NDR_CHECK(ndr_push_drsuapi_DsMembershipType(ndr, NDR_SCALARS, r->type));
4996                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
4997                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4998         }
4999         if (ndr_flags & NDR_BUFFERS) {
5000                 if (r->info_array) {
5001                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5002                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5003                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
5004                         }
5005                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5006                                 if (r->info_array[cntr_info_array_1]) {
5007                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5008                                 }
5009                         }
5010                 }
5011                 if (r->domain) {
5012                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5013                 }
5014         }
5015         return NDR_ERR_SUCCESS;
5016 }
5017
5018 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsRequest1 *r)
5019 {
5020         uint32_t _ptr_info_array;
5021         uint32_t cntr_info_array_1;
5022         TALLOC_CTX *_mem_save_info_array_0;
5023         TALLOC_CTX *_mem_save_info_array_1;
5024         TALLOC_CTX *_mem_save_info_array_2;
5025         uint32_t _ptr_domain;
5026         TALLOC_CTX *_mem_save_domain_0;
5027         if (ndr_flags & NDR_SCALARS) {
5028                 NDR_CHECK(ndr_pull_align(ndr, 5));
5029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5030                 if (r->count < 1 || r->count > 10000) {
5031                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5032                 }
5033                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5034                 if (_ptr_info_array) {
5035                         NDR_PULL_ALLOC(ndr, r->info_array);
5036                 } else {
5037                         r->info_array = NULL;
5038                 }
5039                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
5040                 NDR_CHECK(ndr_pull_drsuapi_DsMembershipType(ndr, NDR_SCALARS, &r->type));
5041                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
5042                 if (_ptr_domain) {
5043                         NDR_PULL_ALLOC(ndr, r->domain);
5044                 } else {
5045                         r->domain = NULL;
5046                 }
5047                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5048         }
5049         if (ndr_flags & NDR_BUFFERS) {
5050                 if (r->info_array) {
5051                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5052                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5053                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
5054                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
5055                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5056                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5057                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5058                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5059                                 if (_ptr_info_array) {
5060                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
5061                                 } else {
5062                                         r->info_array[cntr_info_array_1] = NULL;
5063                                 }
5064                         }
5065                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5066                                 if (r->info_array[cntr_info_array_1]) {
5067                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
5068                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
5069                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5070                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
5071                                 }
5072                         }
5073                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
5074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
5075                 }
5076                 if (r->domain) {
5077                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
5078                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
5079                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5080                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
5081                 }
5082                 if (r->info_array) {
5083                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->count));
5084                 }
5085         }
5086         return NDR_ERR_SUCCESS;
5087 }
5088
5089 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsRequest1 *r)
5090 {
5091         uint32_t cntr_info_array_1;
5092         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsRequest1");
5093         ndr->depth++;
5094         ndr_print_uint32(ndr, "count", r->count);
5095         ndr_print_ptr(ndr, "info_array", r->info_array);
5096         ndr->depth++;
5097         if (r->info_array) {
5098                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->count);
5099                 ndr->depth++;
5100                 for (cntr_info_array_1=0;cntr_info_array_1<r->count;cntr_info_array_1++) {
5101                         char *idx_1=NULL;
5102                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
5103                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
5104                                 ndr->depth++;
5105                                 if (r->info_array[cntr_info_array_1]) {
5106                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
5107                                 }
5108                                 ndr->depth--;
5109                                 free(idx_1);
5110                         }
5111                 }
5112                 ndr->depth--;
5113         }
5114         ndr->depth--;
5115         ndr_print_uint32(ndr, "flags", r->flags);
5116         ndr_print_drsuapi_DsMembershipType(ndr, "type", r->type);
5117         ndr_print_ptr(ndr, "domain", r->domain);
5118         ndr->depth++;
5119         if (r->domain) {
5120                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "domain", r->domain);
5121         }
5122         ndr->depth--;
5123         ndr->depth--;
5124 }
5125
5126 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsRequest *r)
5127 {
5128         if (ndr_flags & NDR_SCALARS) {
5129                 int level = ndr_push_get_switch_value(ndr, r);
5130                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5131                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5132                 switch (level) {
5133                         case 1: {
5134                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5135                         break; }
5136
5137                         default:
5138                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5139                 }
5140         }
5141         if (ndr_flags & NDR_BUFFERS) {
5142                 int level = ndr_push_get_switch_value(ndr, r);
5143                 switch (level) {
5144                         case 1:
5145                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5146                         break;
5147
5148                         default:
5149                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5150                 }
5151         }
5152         return NDR_ERR_SUCCESS;
5153 }
5154
5155 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsRequest *r)
5156 {
5157         int level;
5158         int32_t _level;
5159         level = ndr_pull_get_switch_value(ndr, r);
5160         if (ndr_flags & NDR_SCALARS) {
5161                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5162                 if (_level != level) {
5163                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5164                 }
5165                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5166                 switch (level) {
5167                         case 1: {
5168                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5169                         break; }
5170
5171                         default:
5172                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5173                 }
5174         }
5175         if (ndr_flags & NDR_BUFFERS) {
5176                 switch (level) {
5177                         case 1:
5178                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5179                         break;
5180
5181                         default:
5182                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5183                 }
5184         }
5185         return NDR_ERR_SUCCESS;
5186 }
5187
5188 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsRequest *r)
5189 {
5190         int level;
5191         level = ndr_print_get_switch_value(ndr, r);
5192         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsRequest");
5193         switch (level) {
5194                 case 1:
5195                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req1", &r->req1);
5196                 break;
5197
5198                 default:
5199                         ndr_print_bad_level(ndr, name, level);
5200         }
5201 }
5202
5203 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5204 {
5205         if (ndr_flags & NDR_SCALARS) {
5206                 NDR_CHECK(ndr_push_align(ndr, 5));
5207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
5208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
5209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
5210                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
5211                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5212         }
5213         if (ndr_flags & NDR_BUFFERS) {
5214                 if (r->data) {
5215                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
5216                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
5217                 }
5218         }
5219         return NDR_ERR_SUCCESS;
5220 }
5221
5222 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5223 {
5224         uint32_t _ptr_data;
5225         TALLOC_CTX *_mem_save_data_0;
5226         if (ndr_flags & NDR_SCALARS) {
5227                 NDR_CHECK(ndr_pull_align(ndr, 5));
5228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
5229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
5230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
5231                 if (r->length > 0x00A00000) {
5232                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5233                 }
5234                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
5235                 if (_ptr_data) {
5236                         NDR_PULL_ALLOC(ndr, r->data);
5237                 } else {
5238                         r->data = NULL;
5239                 }
5240                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5241         }
5242         if (ndr_flags & NDR_BUFFERS) {
5243                 if (r->data) {
5244                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5245                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
5246                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
5247                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
5248                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
5249                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
5250                 }
5251                 if (r->data) {
5252                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
5253                 }
5254         }
5255         return NDR_ERR_SUCCESS;
5256 }
5257
5258 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5259 {
5260         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogRequest1");
5261         ndr->depth++;
5262         ndr_print_uint32(ndr, "unknown1", r->unknown1);
5263         ndr_print_uint32(ndr, "unknown2", r->unknown2);
5264         ndr_print_uint32(ndr, "length", r->length);
5265         ndr_print_ptr(ndr, "data", r->data);
5266         ndr->depth++;
5267         if (r->data) {
5268                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
5269         }
5270         ndr->depth--;
5271         ndr->depth--;
5272 }
5273
5274 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5275 {
5276         if (ndr_flags & NDR_SCALARS) {
5277                 int level = ndr_push_get_switch_value(ndr, r);
5278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5279                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5280                 switch (level) {
5281                         case 1: {
5282                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5283                         break; }
5284
5285                         default:
5286                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5287                 }
5288         }
5289         if (ndr_flags & NDR_BUFFERS) {
5290                 int level = ndr_push_get_switch_value(ndr, r);
5291                 switch (level) {
5292                         case 1:
5293                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5294                         break;
5295
5296                         default:
5297                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5298                 }
5299         }
5300         return NDR_ERR_SUCCESS;
5301 }
5302
5303 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogRequest *r)
5304 {
5305         int level;
5306         uint32_t _level;
5307         level = ndr_pull_get_switch_value(ndr, r);
5308         if (ndr_flags & NDR_SCALARS) {
5309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5310                 if (_level != level) {
5311                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5312                 }
5313                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5314                 switch (level) {
5315                         case 1: {
5316                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5317                         break; }
5318
5319                         default:
5320                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5321                 }
5322         }
5323         if (ndr_flags & NDR_BUFFERS) {
5324                 switch (level) {
5325                         case 1:
5326                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5327                         break;
5328
5329                         default:
5330                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5331                 }
5332         }
5333         return NDR_ERR_SUCCESS;
5334 }
5335
5336 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5337 {
5338         int level;
5339         level = ndr_print_get_switch_value(ndr, r);
5340         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogRequest");
5341         switch (level) {
5342                 case 1:
5343                         ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(ndr, "req1", &r->req1);
5344                 break;
5345
5346                 default:
5347                         ndr_print_bad_level(ndr, name, level);
5348         }
5349 }
5350
5351 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5352 {
5353         if (ndr_flags & NDR_SCALARS) {
5354                 NDR_CHECK(ndr_push_align(ndr, 8));
5355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
5356                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
5357                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5358                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time2));
5359                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5360                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time4));
5361                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5362                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time6));
5363                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
5364                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data1));
5365                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data2));
5366                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5367         }
5368         if (ndr_flags & NDR_BUFFERS) {
5369                 if (r->data1) {
5370                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length1));
5371                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data1, r->length1));
5372                 }
5373                 if (r->data2) {
5374                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length2));
5375                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data2, r->length2));
5376                 }
5377         }
5378         return NDR_ERR_SUCCESS;
5379 }
5380
5381 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5382 {
5383         uint32_t _ptr_data1;
5384         TALLOC_CTX *_mem_save_data1_0;
5385         uint32_t _ptr_data2;
5386         TALLOC_CTX *_mem_save_data2_0;
5387         if (ndr_flags & NDR_SCALARS) {
5388                 NDR_CHECK(ndr_pull_align(ndr, 8));
5389                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length1));
5390                 if (r->length1 > 0x00A00000) {
5391                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5392                 }
5393                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length2));
5394                 if (r->length2 > 0x00A00000) {
5395                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5396                 }
5397                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5398                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time2));
5399                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5400                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time4));
5401                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5402                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time6));
5403                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
5404                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data1));
5405                 if (_ptr_data1) {
5406                         NDR_PULL_ALLOC(ndr, r->data1);
5407                 } else {
5408                         r->data1 = NULL;
5409                 }
5410                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data2));
5411                 if (_ptr_data2) {
5412                         NDR_PULL_ALLOC(ndr, r->data2);
5413                 } else {
5414                         r->data2 = NULL;
5415                 }
5416                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5417         }
5418         if (ndr_flags & NDR_BUFFERS) {
5419                 if (r->data1) {
5420                         _mem_save_data1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5421                         NDR_PULL_SET_MEM_CTX(ndr, r->data1, 0);
5422                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data1));
5423                         NDR_PULL_ALLOC_N(ndr, r->data1, ndr_get_array_size(ndr, &r->data1));
5424                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data1, ndr_get_array_size(ndr, &r->data1)));
5425                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data1_0, 0);
5426                 }
5427                 if (r->data2) {
5428                         _mem_save_data2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5429                         NDR_PULL_SET_MEM_CTX(ndr, r->data2, 0);
5430                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data2));
5431                         NDR_PULL_ALLOC_N(ndr, r->data2, ndr_get_array_size(ndr, &r->data2));
5432                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data2, ndr_get_array_size(ndr, &r->data2)));
5433                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data2_0, 0);
5434                 }
5435                 if (r->data1) {
5436                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data1, r->length1));
5437                 }
5438                 if (r->data2) {
5439                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data2, r->length2));
5440                 }
5441         }
5442         return NDR_ERR_SUCCESS;
5443 }
5444
5445 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5446 {
5447         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogInfo1");
5448         ndr->depth++;
5449         ndr_print_uint32(ndr, "length1", r->length1);
5450         ndr_print_uint32(ndr, "length2", r->length2);
5451         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5452         ndr_print_NTTIME(ndr, "time2", r->time2);
5453         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5454         ndr_print_NTTIME(ndr, "time4", r->time4);
5455         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5456         ndr_print_NTTIME(ndr, "time6", r->time6);
5457         ndr_print_NTSTATUS(ndr, "status", r->status);
5458         ndr_print_ptr(ndr, "data1", r->data1);
5459         ndr->depth++;
5460         if (r->data1) {
5461                 ndr_print_array_uint8(ndr, "data1", r->data1, r->length1);
5462         }
5463         ndr->depth--;
5464         ndr_print_ptr(ndr, "data2", r->data2);
5465         ndr->depth++;
5466         if (r->data2) {
5467                 ndr_print_array_uint8(ndr, "data2", r->data2, r->length2);
5468         }
5469         ndr->depth--;
5470         ndr->depth--;
5471 }
5472
5473 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5474 {
5475         if (ndr_flags & NDR_SCALARS) {
5476                 int level = ndr_push_get_switch_value(ndr, r);
5477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5478                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5479                 switch (level) {
5480                         case 1: {
5481                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5482                         break; }
5483
5484                         default:
5485                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5486                 }
5487         }
5488         if (ndr_flags & NDR_BUFFERS) {
5489                 int level = ndr_push_get_switch_value(ndr, r);
5490                 switch (level) {
5491                         case 1:
5492                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5493                         break;
5494
5495                         default:
5496                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5497                 }
5498         }
5499         return NDR_ERR_SUCCESS;
5500 }
5501
5502 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogInfo *r)
5503 {
5504         int level;
5505         uint32_t _level;
5506         level = ndr_pull_get_switch_value(ndr, r);
5507         if (ndr_flags & NDR_SCALARS) {
5508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5509                 if (_level != level) {
5510                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5511                 }
5512                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5513                 switch (level) {
5514                         case 1: {
5515                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5516                         break; }
5517
5518                         default:
5519                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5520                 }
5521         }
5522         if (ndr_flags & NDR_BUFFERS) {
5523                 switch (level) {
5524                         case 1:
5525                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5526                         break;
5527
5528                         default:
5529                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5530                 }
5531         }
5532         return NDR_ERR_SUCCESS;
5533 }
5534
5535 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5536 {
5537         int level;
5538         level = ndr_print_get_switch_value(ndr, r);
5539         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogInfo");
5540         switch (level) {
5541                 case 1:
5542                         ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(ndr, "info1", &r->info1);
5543                 break;
5544
5545                 default:
5546                         ndr_print_bad_level(ndr, name, level);
5547         }
5548 }
5549
5550 static enum ndr_err_code ndr_push_drsuapi_DsNameStatus(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameStatus r)
5551 {
5552         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5553         return NDR_ERR_SUCCESS;
5554 }
5555
5556 static enum ndr_err_code ndr_pull_drsuapi_DsNameStatus(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameStatus *r)
5557 {
5558         uint32_t v;
5559         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5560         *r = v;
5561         return NDR_ERR_SUCCESS;
5562 }
5563
5564 _PUBLIC_ void ndr_print_drsuapi_DsNameStatus(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameStatus r)
5565 {
5566         const char *val = NULL;
5567
5568         switch (r) {
5569                 case DRSUAPI_DS_NAME_STATUS_OK: val = "DRSUAPI_DS_NAME_STATUS_OK"; break;
5570                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR: val = "DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR"; break;
5571                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND: val = "DRSUAPI_DS_NAME_STATUS_NOT_FOUND"; break;
5572                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE: val = "DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE"; break;
5573                 case DRSUAPI_DS_NAME_STATUS_NO_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_MAPPING"; break;
5574                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY: val = "DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY"; break;
5575                 case DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING"; break;
5576                 case DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL"; break;
5577         }
5578         ndr_print_enum(ndr, name, "ENUM", val, r);
5579 }
5580
5581 static enum ndr_err_code ndr_push_drsuapi_DsNameFlags(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFlags r)
5582 {
5583         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5584         return NDR_ERR_SUCCESS;
5585 }
5586
5587 static enum ndr_err_code ndr_pull_drsuapi_DsNameFlags(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFlags *r)
5588 {
5589         uint32_t v;
5590         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5591         *r = v;
5592         return NDR_ERR_SUCCESS;
5593 }
5594
5595 _PUBLIC_ void ndr_print_drsuapi_DsNameFlags(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFlags r)
5596 {
5597         const char *val = NULL;
5598
5599         switch (r) {
5600                 case DRSUAPI_DS_NAME_FLAG_NO_FLAGS: val = "DRSUAPI_DS_NAME_FLAG_NO_FLAGS"; break;
5601                 case DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY: val = "DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY"; break;
5602                 case DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC: val = "DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC"; break;
5603                 case DRSUAPI_DS_NAME_FLAG_GCVERIFY: val = "DRSUAPI_DS_NAME_FLAG_GCVERIFY"; break;
5604                 case DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL"; break;
5605         }
5606         ndr_print_enum(ndr, name, "ENUM", val, r);
5607 }
5608
5609 static enum ndr_err_code ndr_push_drsuapi_DsNameFormat(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFormat r)
5610 {
5611         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5612         return NDR_ERR_SUCCESS;
5613 }
5614
5615 static enum ndr_err_code ndr_pull_drsuapi_DsNameFormat(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFormat *r)
5616 {
5617         uint32_t v;
5618         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5619         *r = v;
5620         return NDR_ERR_SUCCESS;
5621 }
5622
5623 _PUBLIC_ void ndr_print_drsuapi_DsNameFormat(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFormat r)
5624 {
5625         const char *val = NULL;
5626
5627         switch (r) {
5628                 case DRSUAPI_DS_NAME_FORMAT_UNKNOWN: val = "DRSUAPI_DS_NAME_FORMAT_UNKNOWN"; break;
5629                 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: val = "DRSUAPI_DS_NAME_FORMAT_FQDN_1779"; break;
5630                 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: val = "DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT"; break;
5631                 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: val = "DRSUAPI_DS_NAME_FORMAT_DISPLAY"; break;
5632                 case DRSUAPI_DS_NAME_FORMAT_GUID: val = "DRSUAPI_DS_NAME_FORMAT_GUID"; break;
5633                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL"; break;
5634                 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL"; break;
5635                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX"; break;
5636                 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL"; break;
5637                 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: val = "DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY"; break;
5638                 case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: val = "DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN"; break;
5639         }
5640         ndr_print_enum(ndr, name, "ENUM", val, r);
5641 }
5642
5643 static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameString *r)
5644 {
5645         if (ndr_flags & NDR_SCALARS) {
5646                 NDR_CHECK(ndr_push_align(ndr, 5));
5647                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
5648                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5649         }
5650         if (ndr_flags & NDR_BUFFERS) {
5651                 if (r->str) {
5652                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5653                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5655                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str, ndr_charset_length(r->str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5656                 }
5657         }
5658         return NDR_ERR_SUCCESS;
5659 }
5660
5661 static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameString *r)
5662 {
5663         uint32_t _ptr_str;
5664         TALLOC_CTX *_mem_save_str_0;
5665         if (ndr_flags & NDR_SCALARS) {
5666                 NDR_CHECK(ndr_pull_align(ndr, 5));
5667                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
5668                 if (_ptr_str) {
5669                         NDR_PULL_ALLOC(ndr, r->str);
5670                 } else {
5671                         r->str = NULL;
5672                 }
5673                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5674         }
5675         if (ndr_flags & NDR_BUFFERS) {
5676                 if (r->str) {
5677                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
5678                         NDR_PULL_SET_MEM_CTX(ndr, r->str, 0);
5679                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str));
5680                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str));
5681                         if (ndr_get_array_length(ndr, &r->str) > ndr_get_array_size(ndr, &r->str)) {
5682                                 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));
5683                         }
5684                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t)));
5685                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t), CH_UTF16));
5686                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
5687                 }
5688         }
5689         return NDR_ERR_SUCCESS;
5690 }
5691
5692 _PUBLIC_ void ndr_print_drsuapi_DsNameString(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameString *r)
5693 {
5694         ndr_print_struct(ndr, name, "drsuapi_DsNameString");
5695         ndr->depth++;
5696         ndr_print_ptr(ndr, "str", r->str);
5697         ndr->depth++;
5698         if (r->str) {
5699                 ndr_print_string(ndr, "str", r->str);
5700         }
5701         ndr->depth--;
5702         ndr->depth--;
5703 }
5704
5705 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameRequest1 *r)
5706 {
5707         uint32_t cntr_names_1;
5708         if (ndr_flags & NDR_SCALARS) {
5709                 NDR_CHECK(ndr_push_align(ndr, 5));
5710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->codepage));
5711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->language));
5712                 NDR_CHECK(ndr_push_drsuapi_DsNameFlags(ndr, NDR_SCALARS, r->format_flags));
5713                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_offered));
5714                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
5715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
5717                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5718         }
5719         if (ndr_flags & NDR_BUFFERS) {
5720                 if (r->names) {
5721                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5722                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5723                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5724                         }
5725                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5726                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5727                         }
5728                 }
5729         }
5730         return NDR_ERR_SUCCESS;
5731 }
5732
5733 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameRequest1 *r)
5734 {
5735         uint32_t _ptr_names;
5736         uint32_t cntr_names_1;
5737         TALLOC_CTX *_mem_save_names_0;
5738         TALLOC_CTX *_mem_save_names_1;
5739         if (ndr_flags & NDR_SCALARS) {
5740                 NDR_CHECK(ndr_pull_align(ndr, 5));
5741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->codepage));
5742                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->language));
5743                 NDR_CHECK(ndr_pull_drsuapi_DsNameFlags(ndr, NDR_SCALARS, &r->format_flags));
5744                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_offered));
5745                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_desired));
5746                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5747                 if (r->count < 1 || r->count > 10000) {
5748                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5749                 }
5750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
5751                 if (_ptr_names) {
5752                         NDR_PULL_ALLOC(ndr, r->names);
5753                 } else {
5754                         r->names = NULL;
5755                 }
5756                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5757         }
5758         if (ndr_flags & NDR_BUFFERS) {
5759                 if (r->names) {
5760                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5761                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5762                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
5763                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
5764                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
5765                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5766                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5767                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5768                         }
5769                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5770                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5771                         }
5772                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
5773                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
5774                 }
5775                 if (r->names) {
5776                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
5777                 }
5778         }
5779         return NDR_ERR_SUCCESS;
5780 }
5781
5782 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameRequest1 *r)
5783 {
5784         uint32_t cntr_names_1;
5785         ndr_print_struct(ndr, name, "drsuapi_DsNameRequest1");
5786         ndr->depth++;
5787         ndr_print_uint32(ndr, "codepage", r->codepage);
5788         ndr_print_uint32(ndr, "language", r->language);
5789         ndr_print_drsuapi_DsNameFlags(ndr, "format_flags", r->format_flags);
5790         ndr_print_drsuapi_DsNameFormat(ndr, "format_offered", r->format_offered);
5791         ndr_print_drsuapi_DsNameFormat(ndr, "format_desired", r->format_desired);
5792         ndr_print_uint32(ndr, "count", r->count);
5793         ndr_print_ptr(ndr, "names", r->names);
5794         ndr->depth++;
5795         if (r->names) {
5796                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
5797                 ndr->depth++;
5798                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
5799                         char *idx_1=NULL;
5800                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
5801                                 ndr_print_drsuapi_DsNameString(ndr, "names", &r->names[cntr_names_1]);
5802                                 free(idx_1);
5803                         }
5804                 }
5805                 ndr->depth--;
5806         }
5807         ndr->depth--;
5808         ndr->depth--;
5809 }
5810
5811 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameRequest *r)
5812 {
5813         if (ndr_flags & NDR_SCALARS) {
5814                 int level = ndr_push_get_switch_value(ndr, r);
5815                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5816                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5817                 switch (level) {
5818                         case 1: {
5819                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5820                         break; }
5821
5822                         default:
5823                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5824                 }
5825         }
5826         if (ndr_flags & NDR_BUFFERS) {
5827                 int level = ndr_push_get_switch_value(ndr, r);
5828                 switch (level) {
5829                         case 1:
5830                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5831                         break;
5832
5833                         default:
5834                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5835                 }
5836         }
5837         return NDR_ERR_SUCCESS;
5838 }
5839
5840 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameRequest *r)
5841 {
5842         int level;
5843         int32_t _level;
5844         level = ndr_pull_get_switch_value(ndr, r);
5845         if (ndr_flags & NDR_SCALARS) {
5846                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5847                 if (_level != level) {
5848                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5849                 }
5850                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5851                 switch (level) {
5852                         case 1: {
5853                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5854                         break; }
5855
5856                         default:
5857                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5858                 }
5859         }
5860         if (ndr_flags & NDR_BUFFERS) {
5861                 switch (level) {
5862                         case 1:
5863                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5864                         break;
5865
5866                         default:
5867                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5868                 }
5869         }
5870         return NDR_ERR_SUCCESS;
5871 }
5872
5873 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameRequest *r)
5874 {
5875         int level;
5876         level = ndr_print_get_switch_value(ndr, r);
5877         ndr_print_union(ndr, name, level, "drsuapi_DsNameRequest");
5878         switch (level) {
5879                 case 1:
5880                         ndr_print_drsuapi_DsNameRequest1(ndr, "req1", &r->req1);
5881                 break;
5882
5883                 default:
5884                         ndr_print_bad_level(ndr, name, level);
5885         }
5886 }
5887
5888 static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameInfo1 *r)
5889 {
5890         if (ndr_flags & NDR_SCALARS) {
5891                 NDR_CHECK(ndr_push_align(ndr, 5));
5892                 NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
5893                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
5894                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
5895                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5896         }
5897         if (ndr_flags & NDR_BUFFERS) {
5898                 if (r->dns_domain_name) {
5899                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5900                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5901                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5902                         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));
5903                 }
5904                 if (r->result_name) {
5905                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5906                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5907                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5908                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->result_name, ndr_charset_length(r->result_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5909                 }
5910         }
5911         return NDR_ERR_SUCCESS;
5912 }
5913
5914 static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameInfo1 *r)
5915 {
5916         uint32_t _ptr_dns_domain_name;
5917         TALLOC_CTX *_mem_save_dns_domain_name_0;
5918         uint32_t _ptr_result_name;
5919         TALLOC_CTX *_mem_save_result_name_0;
5920         if (ndr_flags & NDR_SCALARS) {
5921                 NDR_CHECK(ndr_pull_align(ndr, 5));
5922                 NDR_CHECK(ndr_pull_drsuapi_DsNameStatus(ndr, NDR_SCALARS, &r->status));
5923                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain_name));
5924                 if (_ptr_dns_domain_name) {
5925                         NDR_PULL_ALLOC(ndr, r->dns_domain_name);
5926                 } else {
5927                         r->dns_domain_name = NULL;
5928                 }
5929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_result_name));
5930                 if (_ptr_result_name) {
5931                         NDR_PULL_ALLOC(ndr, r->result_name);
5932                 } else {
5933                         r->result_name = NULL;
5934                 }
5935                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5936         }
5937         if (ndr_flags & NDR_BUFFERS) {
5938                 if (r->dns_domain_name) {
5939                         _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5940                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
5941                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain_name));
5942                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain_name));
5943                         if (ndr_get_array_length(ndr, &r->dns_domain_name) > ndr_get_array_size(ndr, &r->dns_domain_name)) {
5944                                 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));
5945                         }
5946                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t)));
5947                         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));
5948                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
5949                 }
5950                 if (r->result_name) {
5951                         _mem_save_result_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5952                         NDR_PULL_SET_MEM_CTX(ndr, r->result_name, 0);
5953                         NDR_CHECK(ndr_pull_array_size(ndr, &r->result_name));
5954                         NDR_CHECK(ndr_pull_array_length(ndr, &r->result_name));
5955                         if (ndr_get_array_length(ndr, &r->result_name) > ndr_get_array_size(ndr, &r->result_name)) {
5956                                 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));
5957                         }
5958                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t)));
5959                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t), CH_UTF16));
5960                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_result_name_0, 0);
5961                 }
5962         }
5963         return NDR_ERR_SUCCESS;
5964 }
5965
5966 _PUBLIC_ void ndr_print_drsuapi_DsNameInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameInfo1 *r)
5967 {
5968         ndr_print_struct(ndr, name, "drsuapi_DsNameInfo1");
5969         ndr->depth++;
5970         ndr_print_drsuapi_DsNameStatus(ndr, "status", r->status);
5971         ndr_print_ptr(ndr, "dns_domain_name", r->dns_domain_name);
5972         ndr->depth++;
5973         if (r->dns_domain_name) {
5974                 ndr_print_string(ndr, "dns_domain_name", r->dns_domain_name);
5975         }
5976         ndr->depth--;
5977         ndr_print_ptr(ndr, "result_name", r->result_name);
5978         ndr->depth++;
5979         if (r->result_name) {
5980                 ndr_print_string(ndr, "result_name", r->result_name);
5981         }
5982         ndr->depth--;
5983         ndr->depth--;
5984 }
5985
5986 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameCtr1 *r)
5987 {
5988         uint32_t cntr_array_1;
5989         if (ndr_flags & NDR_SCALARS) {
5990                 NDR_CHECK(ndr_push_align(ndr, 5));
5991                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5992                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5993                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5994         }
5995         if (ndr_flags & NDR_BUFFERS) {
5996                 if (r->array) {
5997                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5998                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5999                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6000                         }
6001                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6002                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6003                         }
6004                 }
6005         }
6006         return NDR_ERR_SUCCESS;
6007 }
6008
6009 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameCtr1 *r)
6010 {
6011         uint32_t _ptr_array;
6012         uint32_t cntr_array_1;
6013         TALLOC_CTX *_mem_save_array_0;
6014         TALLOC_CTX *_mem_save_array_1;
6015         if (ndr_flags & NDR_SCALARS) {
6016                 NDR_CHECK(ndr_pull_align(ndr, 5));
6017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6018                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
6019                 if (_ptr_array) {
6020                         NDR_PULL_ALLOC(ndr, r->array);
6021                 } else {
6022                         r->array = NULL;
6023                 }
6024                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6025         }
6026         if (ndr_flags & NDR_BUFFERS) {
6027                 if (r->array) {
6028                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6029                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6030                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
6031                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
6032                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
6033                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6034                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6035                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6036                         }
6037                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6038                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6039                         }
6040                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
6041                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
6042                 }
6043                 if (r->array) {
6044                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
6045                 }
6046         }
6047         return NDR_ERR_SUCCESS;
6048 }
6049
6050 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameCtr1 *r)
6051 {
6052         uint32_t cntr_array_1;
6053         ndr_print_struct(ndr, name, "drsuapi_DsNameCtr1");
6054         ndr->depth++;
6055         ndr_print_uint32(ndr, "count", r->count);
6056         ndr_print_ptr(ndr, "array", r->array);
6057         ndr->depth++;
6058         if (r->array) {
6059                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
6060                 ndr->depth++;
6061                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
6062                         char *idx_1=NULL;
6063                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
6064                                 ndr_print_drsuapi_DsNameInfo1(ndr, "array", &r->array[cntr_array_1]);
6065                                 free(idx_1);
6066                         }
6067                 }
6068                 ndr->depth--;
6069         }
6070         ndr->depth--;
6071         ndr->depth--;
6072 }
6073
6074 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameCtr *r)
6075 {
6076         if (ndr_flags & NDR_SCALARS) {
6077                 int level = ndr_push_get_switch_value(ndr, r);
6078                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6079                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6080                 switch (level) {
6081                         case 1: {
6082                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
6083                         break; }
6084
6085                         default:
6086                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6087                 }
6088         }
6089         if (ndr_flags & NDR_BUFFERS) {
6090                 int level = ndr_push_get_switch_value(ndr, r);
6091                 switch (level) {
6092                         case 1:
6093                                 if (r->ctr1) {
6094                                         NDR_CHECK(ndr_push_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6095                                 }
6096                         break;
6097
6098                         default:
6099                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6100                 }
6101         }
6102         return NDR_ERR_SUCCESS;
6103 }
6104
6105 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameCtr *r)
6106 {
6107         int level;
6108         int32_t _level;
6109         TALLOC_CTX *_mem_save_ctr1_0;
6110         level = ndr_pull_get_switch_value(ndr, r);
6111         if (ndr_flags & NDR_SCALARS) {
6112                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6113                 if (_level != level) {
6114                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6115                 }
6116                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6117                 switch (level) {
6118                         case 1: {
6119                                 uint32_t _ptr_ctr1;
6120                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
6121                                 if (_ptr_ctr1) {
6122                                         NDR_PULL_ALLOC(ndr, r->ctr1);
6123                                 } else {
6124                                         r->ctr1 = NULL;
6125                                 }
6126                         break; }
6127
6128                         default:
6129                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6130                 }
6131         }
6132         if (ndr_flags & NDR_BUFFERS) {
6133                 switch (level) {
6134                         case 1:
6135                                 if (r->ctr1) {
6136                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6137                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
6138                                         NDR_CHECK(ndr_pull_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6139                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
6140                                 }
6141                         break;
6142
6143                         default:
6144                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6145                 }
6146         }
6147         return NDR_ERR_SUCCESS;
6148 }
6149
6150 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameCtr *r)
6151 {
6152         int level;
6153         level = ndr_print_get_switch_value(ndr, r);
6154         ndr_print_union(ndr, name, level, "drsuapi_DsNameCtr");
6155         switch (level) {
6156                 case 1:
6157                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
6158                         ndr->depth++;
6159                         if (r->ctr1) {
6160                                 ndr_print_drsuapi_DsNameCtr1(ndr, "ctr1", r->ctr1);
6161                         }
6162                         ndr->depth--;
6163                 break;
6164
6165                 default:
6166                         ndr_print_bad_level(ndr, name, level);
6167         }
6168 }
6169
6170 static enum ndr_err_code ndr_push_drsuapi_DsSpnOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsSpnOperation r)
6171 {
6172         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6173         return NDR_ERR_SUCCESS;
6174 }
6175
6176 static enum ndr_err_code ndr_pull_drsuapi_DsSpnOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsSpnOperation *r)
6177 {
6178         uint32_t v;
6179         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6180         *r = v;
6181         return NDR_ERR_SUCCESS;
6182 }
6183
6184 _PUBLIC_ void ndr_print_drsuapi_DsSpnOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsSpnOperation r)
6185 {
6186         const char *val = NULL;
6187
6188         switch (r) {
6189                 case DRSUAPI_DS_SPN_OPERATION_ADD: val = "DRSUAPI_DS_SPN_OPERATION_ADD"; break;
6190                 case DRSUAPI_DS_SPN_OPERATION_REPLACE: val = "DRSUAPI_DS_SPN_OPERATION_REPLACE"; break;
6191                 case DRSUAPI_DS_SPN_OPERATION_DELETE: val = "DRSUAPI_DS_SPN_OPERATION_DELETE"; break;
6192         }
6193         ndr_print_enum(ndr, name, "ENUM", val, r);
6194 }
6195
6196 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6197 {
6198         uint32_t cntr_spn_names_1;
6199         if (ndr_flags & NDR_SCALARS) {
6200                 NDR_CHECK(ndr_push_align(ndr, 5));
6201                 NDR_CHECK(ndr_push_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, r->operation));
6202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
6203                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
6204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6205                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
6206                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6207         }
6208         if (ndr_flags & NDR_BUFFERS) {
6209                 if (r->object_dn) {
6210                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6211                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6212                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6213                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6214                 }
6215                 if (r->spn_names) {
6216                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6217                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6218                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6219                         }
6220                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6221                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6222                         }
6223                 }
6224         }
6225         return NDR_ERR_SUCCESS;
6226 }
6227
6228 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnRequest1 *r)
6229 {
6230         uint32_t _ptr_object_dn;
6231         TALLOC_CTX *_mem_save_object_dn_0;
6232         uint32_t _ptr_spn_names;
6233         uint32_t cntr_spn_names_1;
6234         TALLOC_CTX *_mem_save_spn_names_0;
6235         TALLOC_CTX *_mem_save_spn_names_1;
6236         if (ndr_flags & NDR_SCALARS) {
6237                 NDR_CHECK(ndr_pull_align(ndr, 5));
6238                 NDR_CHECK(ndr_pull_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, &r->operation));
6239                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
6240                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
6241                 if (_ptr_object_dn) {
6242                         NDR_PULL_ALLOC(ndr, r->object_dn);
6243                 } else {
6244                         r->object_dn = NULL;
6245                 }
6246                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6247                 if (r->count > 10000) {
6248                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6249                 }
6250                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_spn_names));
6251                 if (_ptr_spn_names) {
6252                         NDR_PULL_ALLOC(ndr, r->spn_names);
6253                 } else {
6254                         r->spn_names = NULL;
6255                 }
6256                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6257         }
6258         if (ndr_flags & NDR_BUFFERS) {
6259                 if (r->object_dn) {
6260                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6261                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
6262                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
6263                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
6264                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
6265                                 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));
6266                         }
6267                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
6268                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
6269                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
6270                 }
6271                 if (r->spn_names) {
6272                         _mem_save_spn_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6273                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6274                         NDR_CHECK(ndr_pull_array_size(ndr, &r->spn_names));
6275                         NDR_PULL_ALLOC_N(ndr, r->spn_names, ndr_get_array_size(ndr, &r->spn_names));
6276                         _mem_save_spn_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
6277                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6278                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6279                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6280                         }
6281                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6282                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6283                         }
6284                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_1, 0);
6285                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_0, 0);
6286                 }
6287                 if (r->spn_names) {
6288                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->spn_names, r->count));
6289                 }
6290         }
6291         return NDR_ERR_SUCCESS;
6292 }
6293
6294 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6295 {
6296         uint32_t cntr_spn_names_1;
6297         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnRequest1");
6298         ndr->depth++;
6299         ndr_print_drsuapi_DsSpnOperation(ndr, "operation", r->operation);
6300         ndr_print_uint32(ndr, "unknown1", r->unknown1);
6301         ndr_print_ptr(ndr, "object_dn", r->object_dn);
6302         ndr->depth++;
6303         if (r->object_dn) {
6304                 ndr_print_string(ndr, "object_dn", r->object_dn);
6305         }
6306         ndr->depth--;
6307         ndr_print_uint32(ndr, "count", r->count);
6308         ndr_print_ptr(ndr, "spn_names", r->spn_names);
6309         ndr->depth++;
6310         if (r->spn_names) {
6311                 ndr->print(ndr, "%s: ARRAY(%d)", "spn_names", (int)r->count);
6312                 ndr->depth++;
6313                 for (cntr_spn_names_1=0;cntr_spn_names_1<r->count;cntr_spn_names_1++) {
6314                         char *idx_1=NULL;
6315                         if (asprintf(&idx_1, "[%d]", cntr_spn_names_1) != -1) {
6316                                 ndr_print_drsuapi_DsNameString(ndr, "spn_names", &r->spn_names[cntr_spn_names_1]);
6317                                 free(idx_1);
6318                         }
6319                 }
6320                 ndr->depth--;
6321         }
6322         ndr->depth--;
6323         ndr->depth--;
6324 }
6325
6326 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnRequest *r)
6327 {
6328         if (ndr_flags & NDR_SCALARS) {
6329                 int level = ndr_push_get_switch_value(ndr, r);
6330                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6331                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6332                 switch (level) {
6333                         case 1: {
6334                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6335                         break; }
6336
6337                         default:
6338                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6339                 }
6340         }
6341         if (ndr_flags & NDR_BUFFERS) {
6342                 int level = ndr_push_get_switch_value(ndr, r);
6343                 switch (level) {
6344                         case 1:
6345                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6346                         break;
6347
6348                         default:
6349                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6350                 }
6351         }
6352         return NDR_ERR_SUCCESS;
6353 }
6354
6355 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnRequest *r)
6356 {
6357         int level;
6358         int32_t _level;
6359         level = ndr_pull_get_switch_value(ndr, r);
6360         if (ndr_flags & NDR_SCALARS) {
6361                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6362                 if (_level != level) {
6363                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6364                 }
6365                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6366                 switch (level) {
6367                         case 1: {
6368                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6369                         break; }
6370
6371                         default:
6372                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6373                 }
6374         }
6375         if (ndr_flags & NDR_BUFFERS) {
6376                 switch (level) {
6377                         case 1:
6378                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6379                         break;
6380
6381                         default:
6382                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6383                 }
6384         }
6385         return NDR_ERR_SUCCESS;
6386 }
6387
6388 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnRequest *r)
6389 {
6390         int level;
6391         level = ndr_print_get_switch_value(ndr, r);
6392         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnRequest");
6393         switch (level) {
6394                 case 1:
6395                         ndr_print_drsuapi_DsWriteAccountSpnRequest1(ndr, "req1", &r->req1);
6396                 break;
6397
6398                 default:
6399                         ndr_print_bad_level(ndr, name, level);
6400         }
6401 }
6402
6403 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6404 {
6405         if (ndr_flags & NDR_SCALARS) {
6406                 NDR_CHECK(ndr_push_align(ndr, 4));
6407                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
6408                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6409         }
6410         if (ndr_flags & NDR_BUFFERS) {
6411         }
6412         return NDR_ERR_SUCCESS;
6413 }
6414
6415 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnResult1 *r)
6416 {
6417         if (ndr_flags & NDR_SCALARS) {
6418                 NDR_CHECK(ndr_pull_align(ndr, 4));
6419                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
6420                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6421         }
6422         if (ndr_flags & NDR_BUFFERS) {
6423         }
6424         return NDR_ERR_SUCCESS;
6425 }
6426
6427 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6428 {
6429         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnResult1");
6430         ndr->depth++;
6431         ndr_print_WERROR(ndr, "status", r->status);
6432         ndr->depth--;
6433 }
6434
6435 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnResult *r)
6436 {
6437         if (ndr_flags & NDR_SCALARS) {
6438                 int level = ndr_push_get_switch_value(ndr, r);
6439                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6440                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6441                 switch (level) {
6442                         case 1: {
6443                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6444                         break; }
6445
6446                         default:
6447                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6448                 }
6449         }
6450         if (ndr_flags & NDR_BUFFERS) {
6451                 int level = ndr_push_get_switch_value(ndr, r);
6452                 switch (level) {
6453                         case 1:
6454                         break;
6455
6456                         default:
6457                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6458                 }
6459         }
6460         return NDR_ERR_SUCCESS;
6461 }
6462
6463 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnResult *r)
6464 {
6465         int level;
6466         int32_t _level;
6467         level = ndr_pull_get_switch_value(ndr, r);
6468         if (ndr_flags & NDR_SCALARS) {
6469                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6470                 if (_level != level) {
6471                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6472                 }
6473                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6474                 switch (level) {
6475                         case 1: {
6476                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6477                         break; }
6478
6479                         default:
6480                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6481                 }
6482         }
6483         if (ndr_flags & NDR_BUFFERS) {
6484                 switch (level) {
6485                         case 1:
6486                         break;
6487
6488                         default:
6489                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6490                 }
6491         }
6492         return NDR_ERR_SUCCESS;
6493 }
6494
6495 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnResult *r)
6496 {
6497         int level;
6498         level = ndr_print_get_switch_value(ndr, r);
6499         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnResult");
6500         switch (level) {
6501                 case 1:
6502                         ndr_print_drsuapi_DsWriteAccountSpnResult1(ndr, "res1", &r->res1);
6503                 break;
6504
6505                 default:
6506                         ndr_print_bad_level(ndr, name, level);
6507         }
6508 }
6509
6510 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6511 {
6512         if (ndr_flags & NDR_SCALARS) {
6513                 NDR_CHECK(ndr_push_align(ndr, 5));
6514                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6515                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
6516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->commit));
6517                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6518         }
6519         if (ndr_flags & NDR_BUFFERS) {
6520                 if (r->server_dn) {
6521                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6522                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6523                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6524                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6525                 }
6526                 if (r->domain_dn) {
6527                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6528                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6529                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6530                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_dn, ndr_charset_length(r->domain_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6531                 }
6532         }
6533         return NDR_ERR_SUCCESS;
6534 }
6535
6536 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerRequest1 *r)
6537 {
6538         uint32_t _ptr_server_dn;
6539         TALLOC_CTX *_mem_save_server_dn_0;
6540         uint32_t _ptr_domain_dn;
6541         TALLOC_CTX *_mem_save_domain_dn_0;
6542         if (ndr_flags & NDR_SCALARS) {
6543                 NDR_CHECK(ndr_pull_align(ndr, 5));
6544                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6545                 if (_ptr_server_dn) {
6546                         NDR_PULL_ALLOC(ndr, r->server_dn);
6547                 } else {
6548                         r->server_dn = NULL;
6549                 }
6550                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_dn));
6551                 if (_ptr_domain_dn) {
6552                         NDR_PULL_ALLOC(ndr, r->domain_dn);
6553                 } else {
6554                         r->domain_dn = NULL;
6555                 }
6556                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->commit));
6557                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6558         }
6559         if (ndr_flags & NDR_BUFFERS) {
6560                 if (r->server_dn) {
6561                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6562                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6563                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6564                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6565                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6566                                 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));
6567                         }
6568                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6569                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6570                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6571                 }
6572                 if (r->domain_dn) {
6573                         _mem_save_domain_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6574                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_dn, 0);
6575                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_dn));
6576                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_dn));
6577                         if (ndr_get_array_length(ndr, &r->domain_dn) > ndr_get_array_size(ndr, &r->domain_dn)) {
6578                                 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));
6579                         }
6580                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t)));
6581                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t), CH_UTF16));
6582                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_dn_0, 0);
6583                 }
6584         }
6585         return NDR_ERR_SUCCESS;
6586 }
6587
6588 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6589 {
6590         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerRequest1");
6591         ndr->depth++;
6592         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6593         ndr->depth++;
6594         if (r->server_dn) {
6595                 ndr_print_string(ndr, "server_dn", r->server_dn);
6596         }
6597         ndr->depth--;
6598         ndr_print_ptr(ndr, "domain_dn", r->domain_dn);
6599         ndr->depth++;
6600         if (r->domain_dn) {
6601                 ndr_print_string(ndr, "domain_dn", r->domain_dn);
6602         }
6603         ndr->depth--;
6604         ndr_print_uint32(ndr, "commit", r->commit);
6605         ndr->depth--;
6606 }
6607
6608 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerRequest *r)
6609 {
6610         if (ndr_flags & NDR_SCALARS) {
6611                 int level = ndr_push_get_switch_value(ndr, r);
6612                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6613                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6614                 switch (level) {
6615                         case 1: {
6616                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6617                         break; }
6618
6619                         default:
6620                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6621                 }
6622         }
6623         if (ndr_flags & NDR_BUFFERS) {
6624                 int level = ndr_push_get_switch_value(ndr, r);
6625                 switch (level) {
6626                         case 1:
6627                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6628                         break;
6629
6630                         default:
6631                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6632                 }
6633         }
6634         return NDR_ERR_SUCCESS;
6635 }
6636
6637 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerRequest *r)
6638 {
6639         int level;
6640         int32_t _level;
6641         level = ndr_pull_get_switch_value(ndr, r);
6642         if (ndr_flags & NDR_SCALARS) {
6643                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6644                 if (_level != level) {
6645                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6646                 }
6647                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6648                 switch (level) {
6649                         case 1: {
6650                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6651                         break; }
6652
6653                         default:
6654                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6655                 }
6656         }
6657         if (ndr_flags & NDR_BUFFERS) {
6658                 switch (level) {
6659                         case 1:
6660                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6661                         break;
6662
6663                         default:
6664                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6665                 }
6666         }
6667         return NDR_ERR_SUCCESS;
6668 }
6669
6670 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerRequest *r)
6671 {
6672         int level;
6673         level = ndr_print_get_switch_value(ndr, r);
6674         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerRequest");
6675         switch (level) {
6676                 case 1:
6677                         ndr_print_drsuapi_DsRemoveDSServerRequest1(ndr, "req1", &r->req1);
6678                 break;
6679
6680                 default:
6681                         ndr_print_bad_level(ndr, name, level);
6682         }
6683 }
6684
6685 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerResult1 *r)
6686 {
6687         if (ndr_flags & NDR_SCALARS) {
6688                 NDR_CHECK(ndr_push_align(ndr, 4));
6689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->last_dc_in_domain));
6690                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6691         }
6692         if (ndr_flags & NDR_BUFFERS) {
6693         }
6694         return NDR_ERR_SUCCESS;
6695 }
6696
6697 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerResult1 *r)
6698 {
6699         if (ndr_flags & NDR_SCALARS) {
6700                 NDR_CHECK(ndr_pull_align(ndr, 4));
6701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->last_dc_in_domain));
6702                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6703         }
6704         if (ndr_flags & NDR_BUFFERS) {
6705         }
6706         return NDR_ERR_SUCCESS;
6707 }
6708
6709 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerResult1 *r)
6710 {
6711         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerResult1");
6712         ndr->depth++;
6713         ndr_print_uint32(ndr, "last_dc_in_domain", r->last_dc_in_domain);
6714         ndr->depth--;
6715 }
6716
6717 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerResult *r)
6718 {
6719         if (ndr_flags & NDR_SCALARS) {
6720                 int level = ndr_push_get_switch_value(ndr, r);
6721                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6722                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6723                 switch (level) {
6724                         case 1: {
6725                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6726                         break; }
6727
6728                         default:
6729                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6730                 }
6731         }
6732         if (ndr_flags & NDR_BUFFERS) {
6733                 int level = ndr_push_get_switch_value(ndr, r);
6734                 switch (level) {
6735                         case 1:
6736                         break;
6737
6738                         default:
6739                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6740                 }
6741         }
6742         return NDR_ERR_SUCCESS;
6743 }
6744
6745 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerResult *r)
6746 {
6747         int level;
6748         int32_t _level;
6749         level = ndr_pull_get_switch_value(ndr, r);
6750         if (ndr_flags & NDR_SCALARS) {
6751                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6752                 if (_level != level) {
6753                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6754                 }
6755                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6756                 switch (level) {
6757                         case 1: {
6758                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6759                         break; }
6760
6761                         default:
6762                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6763                 }
6764         }
6765         if (ndr_flags & NDR_BUFFERS) {
6766                 switch (level) {
6767                         case 1:
6768                         break;
6769
6770                         default:
6771                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6772                 }
6773         }
6774         return NDR_ERR_SUCCESS;
6775 }
6776
6777 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerResult *r)
6778 {
6779         int level;
6780         level = ndr_print_get_switch_value(ndr, r);
6781         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerResult");
6782         switch (level) {
6783                 case 1:
6784                         ndr_print_drsuapi_DsRemoveDSServerResult1(ndr, "res1", &r->res1);
6785                 break;
6786
6787                 default:
6788                         ndr_print_bad_level(ndr, name, level);
6789         }
6790 }
6791
6792 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoRequest1 *r)
6793 {
6794         if (ndr_flags & NDR_SCALARS) {
6795                 NDR_CHECK(ndr_push_align(ndr, 5));
6796                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
6797                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
6798                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6799         }
6800         if (ndr_flags & NDR_BUFFERS) {
6801                 if (r->domain_name) {
6802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6803                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6805                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6806                 }
6807         }
6808         return NDR_ERR_SUCCESS;
6809 }
6810
6811 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoRequest1 *r)
6812 {
6813         uint32_t _ptr_domain_name;
6814         TALLOC_CTX *_mem_save_domain_name_0;
6815         if (ndr_flags & NDR_SCALARS) {
6816                 NDR_CHECK(ndr_pull_align(ndr, 5));
6817                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
6818                 if (_ptr_domain_name) {
6819                         NDR_PULL_ALLOC(ndr, r->domain_name);
6820                 } else {
6821                         r->domain_name = NULL;
6822                 }
6823                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
6824                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6825         }
6826         if (ndr_flags & NDR_BUFFERS) {
6827                 if (r->domain_name) {
6828                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6829                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
6830                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
6831                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
6832                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
6833                                 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));
6834                         }
6835                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
6836                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
6837                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
6838                 }
6839         }
6840         return NDR_ERR_SUCCESS;
6841 }
6842
6843 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoRequest1 *r)
6844 {
6845         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoRequest1");
6846         ndr->depth++;
6847         ndr_print_ptr(ndr, "domain_name", r->domain_name);
6848         ndr->depth++;
6849         if (r->domain_name) {
6850                 ndr_print_string(ndr, "domain_name", r->domain_name);
6851         }
6852         ndr->depth--;
6853         ndr_print_int32(ndr, "level", r->level);
6854         ndr->depth--;
6855 }
6856
6857 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoRequest *r)
6858 {
6859         if (ndr_flags & NDR_SCALARS) {
6860                 int level = ndr_push_get_switch_value(ndr, r);
6861                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6862                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6863                 switch (level) {
6864                         case 1: {
6865                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6866                         break; }
6867
6868                         default:
6869                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6870                 }
6871         }
6872         if (ndr_flags & NDR_BUFFERS) {
6873                 int level = ndr_push_get_switch_value(ndr, r);
6874                 switch (level) {
6875                         case 1:
6876                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6877                         break;
6878
6879                         default:
6880                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6881                 }
6882         }
6883         return NDR_ERR_SUCCESS;
6884 }
6885
6886 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoRequest *r)
6887 {
6888         int level;
6889         int32_t _level;
6890         level = ndr_pull_get_switch_value(ndr, r);
6891         if (ndr_flags & NDR_SCALARS) {
6892                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6893                 if (_level != level) {
6894                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6895                 }
6896                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6897                 switch (level) {
6898                         case 1: {
6899                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6900                         break; }
6901
6902                         default:
6903                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6904                 }
6905         }
6906         if (ndr_flags & NDR_BUFFERS) {
6907                 switch (level) {
6908                         case 1:
6909                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6910                         break;
6911
6912                         default:
6913                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6914                 }
6915         }
6916         return NDR_ERR_SUCCESS;
6917 }
6918
6919 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoRequest *r)
6920 {
6921         int level;
6922         level = ndr_print_get_switch_value(ndr, r);
6923         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoRequest");
6924         switch (level) {
6925                 case 1:
6926                         ndr_print_drsuapi_DsGetDCInfoRequest1(ndr, "req1", &r->req1);
6927                 break;
6928
6929                 default:
6930                         ndr_print_bad_level(ndr, name, level);
6931         }
6932 }
6933
6934 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo1 *r)
6935 {
6936         if (ndr_flags & NDR_SCALARS) {
6937                 NDR_CHECK(ndr_push_align(ndr, 5));
6938                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6939                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6940                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6942                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6945                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6946         }
6947         if (ndr_flags & NDR_BUFFERS) {
6948                 if (r->netbios_name) {
6949                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6950                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6951                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6952                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6953                 }
6954                 if (r->dns_name) {
6955                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6956                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6957                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6958                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6959                 }
6960                 if (r->site_name) {
6961                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6962                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6963                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6964                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6965                 }
6966                 if (r->computer_dn) {
6967                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6968                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6969                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6970                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6971                 }
6972                 if (r->server_dn) {
6973                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6974                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6975                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6976                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6977                 }
6978         }
6979         return NDR_ERR_SUCCESS;
6980 }
6981
6982 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo1 *r)
6983 {
6984         uint32_t _ptr_netbios_name;
6985         TALLOC_CTX *_mem_save_netbios_name_0;
6986         uint32_t _ptr_dns_name;
6987         TALLOC_CTX *_mem_save_dns_name_0;
6988         uint32_t _ptr_site_name;
6989         TALLOC_CTX *_mem_save_site_name_0;
6990         uint32_t _ptr_computer_dn;
6991         TALLOC_CTX *_mem_save_computer_dn_0;
6992         uint32_t _ptr_server_dn;
6993         TALLOC_CTX *_mem_save_server_dn_0;
6994         if (ndr_flags & NDR_SCALARS) {
6995                 NDR_CHECK(ndr_pull_align(ndr, 5));
6996                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
6997                 if (_ptr_netbios_name) {
6998                         NDR_PULL_ALLOC(ndr, r->netbios_name);
6999                 } else {
7000                         r->netbios_name = NULL;
7001                 }
7002                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7003                 if (_ptr_dns_name) {
7004                         NDR_PULL_ALLOC(ndr, r->dns_name);
7005                 } else {
7006                         r->dns_name = NULL;
7007                 }
7008                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7009                 if (_ptr_site_name) {
7010                         NDR_PULL_ALLOC(ndr, r->site_name);
7011                 } else {
7012                         r->site_name = NULL;
7013                 }
7014                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7015                 if (_ptr_computer_dn) {
7016                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7017                 } else {
7018                         r->computer_dn = NULL;
7019                 }
7020                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7021                 if (_ptr_server_dn) {
7022                         NDR_PULL_ALLOC(ndr, r->server_dn);
7023                 } else {
7024                         r->server_dn = NULL;
7025                 }
7026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7028                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7029         }
7030         if (ndr_flags & NDR_BUFFERS) {
7031                 if (r->netbios_name) {
7032                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7033                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7034                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7035                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7036                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7037                                 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));
7038                         }
7039                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7040                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7041                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7042                 }
7043                 if (r->dns_name) {
7044                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7045                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7046                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7047                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7048                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7049                                 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));
7050                         }
7051                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7052                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7053                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7054                 }
7055                 if (r->site_name) {
7056                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7057                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7058                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7059                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7060                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7061                                 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));
7062                         }
7063                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7064                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7065                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7066                 }
7067                 if (r->computer_dn) {
7068                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7069                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7070                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7071                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7072                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7073                                 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));
7074                         }
7075                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7076                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7077                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7078                 }
7079                 if (r->server_dn) {
7080                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7081                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7082                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7083                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7084                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7085                                 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));
7086                         }
7087                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7088                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7089                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7090                 }
7091         }
7092         return NDR_ERR_SUCCESS;
7093 }
7094
7095 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo1 *r)
7096 {
7097         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo1");
7098         ndr->depth++;
7099         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7100         ndr->depth++;
7101         if (r->netbios_name) {
7102                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7103         }
7104         ndr->depth--;
7105         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7106         ndr->depth++;
7107         if (r->dns_name) {
7108                 ndr_print_string(ndr, "dns_name", r->dns_name);
7109         }
7110         ndr->depth--;
7111         ndr_print_ptr(ndr, "site_name", r->site_name);
7112         ndr->depth++;
7113         if (r->site_name) {
7114                 ndr_print_string(ndr, "site_name", r->site_name);
7115         }
7116         ndr->depth--;
7117         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7118         ndr->depth++;
7119         if (r->computer_dn) {
7120                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7121         }
7122         ndr->depth--;
7123         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7124         ndr->depth++;
7125         if (r->server_dn) {
7126                 ndr_print_string(ndr, "server_dn", r->server_dn);
7127         }
7128         ndr->depth--;
7129         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7130         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7131         ndr->depth--;
7132 }
7133
7134 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr1 *r)
7135 {
7136         uint32_t cntr_array_1;
7137         if (ndr_flags & NDR_SCALARS) {
7138                 NDR_CHECK(ndr_push_align(ndr, 5));
7139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7140                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7141                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7142         }
7143         if (ndr_flags & NDR_BUFFERS) {
7144                 if (r->array) {
7145                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7146                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7147                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7148                         }
7149                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7150                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7151                         }
7152                 }
7153         }
7154         return NDR_ERR_SUCCESS;
7155 }
7156
7157 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr1 *r)
7158 {
7159         uint32_t _ptr_array;
7160         uint32_t cntr_array_1;
7161         TALLOC_CTX *_mem_save_array_0;
7162         TALLOC_CTX *_mem_save_array_1;
7163         if (ndr_flags & NDR_SCALARS) {
7164                 NDR_CHECK(ndr_pull_align(ndr, 5));
7165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7166                 if (r->count > 10000) {
7167                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7168                 }
7169                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7170                 if (_ptr_array) {
7171                         NDR_PULL_ALLOC(ndr, r->array);
7172                 } else {
7173                         r->array = NULL;
7174                 }
7175                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7176         }
7177         if (ndr_flags & NDR_BUFFERS) {
7178                 if (r->array) {
7179                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7180                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7181                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7182                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7183                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7184                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7185                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7186                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7187                         }
7188                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7189                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7190                         }
7191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7192                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7193                 }
7194                 if (r->array) {
7195                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7196                 }
7197         }
7198         return NDR_ERR_SUCCESS;
7199 }
7200
7201 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr1 *r)
7202 {
7203         uint32_t cntr_array_1;
7204         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr1");
7205         ndr->depth++;
7206         ndr_print_uint32(ndr, "count", r->count);
7207         ndr_print_ptr(ndr, "array", r->array);
7208         ndr->depth++;
7209         if (r->array) {
7210                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7211                 ndr->depth++;
7212                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7213                         char *idx_1=NULL;
7214                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7215                                 ndr_print_drsuapi_DsGetDCInfo1(ndr, "array", &r->array[cntr_array_1]);
7216                                 free(idx_1);
7217                         }
7218                 }
7219                 ndr->depth--;
7220         }
7221         ndr->depth--;
7222         ndr->depth--;
7223 }
7224
7225 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo2 *r)
7226 {
7227         if (ndr_flags & NDR_SCALARS) {
7228                 NDR_CHECK(ndr_push_align(ndr, 5));
7229                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7230                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7231                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7232                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7233                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7234                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7235                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7236                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7239                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7240                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7241                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7242                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7243                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7244         }
7245         if (ndr_flags & NDR_BUFFERS) {
7246                 if (r->netbios_name) {
7247                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7248                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7250                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7251                 }
7252                 if (r->dns_name) {
7253                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7254                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7255                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7256                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7257                 }
7258                 if (r->site_name) {
7259                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7260                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7261                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7262                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7263                 }
7264                 if (r->site_dn) {
7265                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7266                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7267                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7268                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7269                 }
7270                 if (r->computer_dn) {
7271                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7272                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7273                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7274                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7275                 }
7276                 if (r->server_dn) {
7277                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7278                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7279                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7280                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7281                 }
7282                 if (r->ntds_dn) {
7283                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7284                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7285                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7286                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7287                 }
7288         }
7289         return NDR_ERR_SUCCESS;
7290 }
7291
7292 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo2 *r)
7293 {
7294         uint32_t _ptr_netbios_name;
7295         TALLOC_CTX *_mem_save_netbios_name_0;
7296         uint32_t _ptr_dns_name;
7297         TALLOC_CTX *_mem_save_dns_name_0;
7298         uint32_t _ptr_site_name;
7299         TALLOC_CTX *_mem_save_site_name_0;
7300         uint32_t _ptr_site_dn;
7301         TALLOC_CTX *_mem_save_site_dn_0;
7302         uint32_t _ptr_computer_dn;
7303         TALLOC_CTX *_mem_save_computer_dn_0;
7304         uint32_t _ptr_server_dn;
7305         TALLOC_CTX *_mem_save_server_dn_0;
7306         uint32_t _ptr_ntds_dn;
7307         TALLOC_CTX *_mem_save_ntds_dn_0;
7308         if (ndr_flags & NDR_SCALARS) {
7309                 NDR_CHECK(ndr_pull_align(ndr, 5));
7310                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7311                 if (_ptr_netbios_name) {
7312                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7313                 } else {
7314                         r->netbios_name = NULL;
7315                 }
7316                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7317                 if (_ptr_dns_name) {
7318                         NDR_PULL_ALLOC(ndr, r->dns_name);
7319                 } else {
7320                         r->dns_name = NULL;
7321                 }
7322                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7323                 if (_ptr_site_name) {
7324                         NDR_PULL_ALLOC(ndr, r->site_name);
7325                 } else {
7326                         r->site_name = NULL;
7327                 }
7328                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7329                 if (_ptr_site_dn) {
7330                         NDR_PULL_ALLOC(ndr, r->site_dn);
7331                 } else {
7332                         r->site_dn = NULL;
7333                 }
7334                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7335                 if (_ptr_computer_dn) {
7336                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7337                 } else {
7338                         r->computer_dn = NULL;
7339                 }
7340                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7341                 if (_ptr_server_dn) {
7342                         NDR_PULL_ALLOC(ndr, r->server_dn);
7343                 } else {
7344                         r->server_dn = NULL;
7345                 }
7346                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7347                 if (_ptr_ntds_dn) {
7348                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7349                 } else {
7350                         r->ntds_dn = NULL;
7351                 }
7352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7355                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7356                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7357                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7358                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7359                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7360         }
7361         if (ndr_flags & NDR_BUFFERS) {
7362                 if (r->netbios_name) {
7363                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7364                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7365                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7366                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7367                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7368                                 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));
7369                         }
7370                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7371                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7372                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7373                 }
7374                 if (r->dns_name) {
7375                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7376                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7377                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7378                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7379                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7380                                 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));
7381                         }
7382                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7383                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7384                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7385                 }
7386                 if (r->site_name) {
7387                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7388                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7389                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7390                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7391                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7392                                 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));
7393                         }
7394                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7395                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7396                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7397                 }
7398                 if (r->site_dn) {
7399                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7400                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7401                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7402                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7403                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7404                                 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));
7405                         }
7406                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7407                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7408                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7409                 }
7410                 if (r->computer_dn) {
7411                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7412                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7413                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7414                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7415                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7416                                 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));
7417                         }
7418                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7419                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7420                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7421                 }
7422                 if (r->server_dn) {
7423                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7424                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7425                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7426                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7427                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7428                                 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));
7429                         }
7430                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7431                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7432                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7433                 }
7434                 if (r->ntds_dn) {
7435                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7436                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7437                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7438                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7439                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7440                                 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));
7441                         }
7442                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7443                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7444                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7445                 }
7446         }
7447         return NDR_ERR_SUCCESS;
7448 }
7449
7450 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo2 *r)
7451 {
7452         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo2");
7453         ndr->depth++;
7454         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7455         ndr->depth++;
7456         if (r->netbios_name) {
7457                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7458         }
7459         ndr->depth--;
7460         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7461         ndr->depth++;
7462         if (r->dns_name) {
7463                 ndr_print_string(ndr, "dns_name", r->dns_name);
7464         }
7465         ndr->depth--;
7466         ndr_print_ptr(ndr, "site_name", r->site_name);
7467         ndr->depth++;
7468         if (r->site_name) {
7469                 ndr_print_string(ndr, "site_name", r->site_name);
7470         }
7471         ndr->depth--;
7472         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7473         ndr->depth++;
7474         if (r->site_dn) {
7475                 ndr_print_string(ndr, "site_dn", r->site_dn);
7476         }
7477         ndr->depth--;
7478         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7479         ndr->depth++;
7480         if (r->computer_dn) {
7481                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7482         }
7483         ndr->depth--;
7484         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7485         ndr->depth++;
7486         if (r->server_dn) {
7487                 ndr_print_string(ndr, "server_dn", r->server_dn);
7488         }
7489         ndr->depth--;
7490         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7491         ndr->depth++;
7492         if (r->ntds_dn) {
7493                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7494         }
7495         ndr->depth--;
7496         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7497         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7498         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7499         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7500         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7501         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7502         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7503         ndr->depth--;
7504 }
7505
7506 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr2 *r)
7507 {
7508         uint32_t cntr_array_1;
7509         if (ndr_flags & NDR_SCALARS) {
7510                 NDR_CHECK(ndr_push_align(ndr, 5));
7511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7512                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7513                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7514         }
7515         if (ndr_flags & NDR_BUFFERS) {
7516                 if (r->array) {
7517                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7518                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7519                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7520                         }
7521                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7522                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7523                         }
7524                 }
7525         }
7526         return NDR_ERR_SUCCESS;
7527 }
7528
7529 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr2 *r)
7530 {
7531         uint32_t _ptr_array;
7532         uint32_t cntr_array_1;
7533         TALLOC_CTX *_mem_save_array_0;
7534         TALLOC_CTX *_mem_save_array_1;
7535         if (ndr_flags & NDR_SCALARS) {
7536                 NDR_CHECK(ndr_pull_align(ndr, 5));
7537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7538                 if (r->count > 10000) {
7539                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7540                 }
7541                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7542                 if (_ptr_array) {
7543                         NDR_PULL_ALLOC(ndr, r->array);
7544                 } else {
7545                         r->array = NULL;
7546                 }
7547                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7548         }
7549         if (ndr_flags & NDR_BUFFERS) {
7550                 if (r->array) {
7551                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7552                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7553                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7554                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7555                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7556                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7557                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7558                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7559                         }
7560                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7561                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7562                         }
7563                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7564                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7565                 }
7566                 if (r->array) {
7567                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7568                 }
7569         }
7570         return NDR_ERR_SUCCESS;
7571 }
7572
7573 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr2 *r)
7574 {
7575         uint32_t cntr_array_1;
7576         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr2");
7577         ndr->depth++;
7578         ndr_print_uint32(ndr, "count", r->count);
7579         ndr_print_ptr(ndr, "array", r->array);
7580         ndr->depth++;
7581         if (r->array) {
7582                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7583                 ndr->depth++;
7584                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7585                         char *idx_1=NULL;
7586                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7587                                 ndr_print_drsuapi_DsGetDCInfo2(ndr, "array", &r->array[cntr_array_1]);
7588                                 free(idx_1);
7589                         }
7590                 }
7591                 ndr->depth--;
7592         }
7593         ndr->depth--;
7594         ndr->depth--;
7595 }
7596
7597 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo3 *r)
7598 {
7599         if (ndr_flags & NDR_SCALARS) {
7600                 NDR_CHECK(ndr_push_align(ndr, 5));
7601                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7602                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7603                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7605                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7608                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7611                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_rodc));
7612                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7613                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7614                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7615                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7616                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7617         }
7618         if (ndr_flags & NDR_BUFFERS) {
7619                 if (r->netbios_name) {
7620                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7621                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7622                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7623                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7624                 }
7625                 if (r->dns_name) {
7626                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7627                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7628                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7629                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7630                 }
7631                 if (r->site_name) {
7632                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7633                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7634                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7635                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7636                 }
7637                 if (r->site_dn) {
7638                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7639                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7640                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7641                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7642                 }
7643                 if (r->computer_dn) {
7644                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7645                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7646                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7647                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7648                 }
7649                 if (r->server_dn) {
7650                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7651                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7652                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7653                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7654                 }
7655                 if (r->ntds_dn) {
7656                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7657                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7658                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7659                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7660                 }
7661         }
7662         return NDR_ERR_SUCCESS;
7663 }
7664
7665 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo3 *r)
7666 {
7667         uint32_t _ptr_netbios_name;
7668         TALLOC_CTX *_mem_save_netbios_name_0;
7669         uint32_t _ptr_dns_name;
7670         TALLOC_CTX *_mem_save_dns_name_0;
7671         uint32_t _ptr_site_name;
7672         TALLOC_CTX *_mem_save_site_name_0;
7673         uint32_t _ptr_site_dn;
7674         TALLOC_CTX *_mem_save_site_dn_0;
7675         uint32_t _ptr_computer_dn;
7676         TALLOC_CTX *_mem_save_computer_dn_0;
7677         uint32_t _ptr_server_dn;
7678         TALLOC_CTX *_mem_save_server_dn_0;
7679         uint32_t _ptr_ntds_dn;
7680         TALLOC_CTX *_mem_save_ntds_dn_0;
7681         if (ndr_flags & NDR_SCALARS) {
7682                 NDR_CHECK(ndr_pull_align(ndr, 5));
7683                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7684                 if (_ptr_netbios_name) {
7685                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7686                 } else {
7687                         r->netbios_name = NULL;
7688                 }
7689                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7690                 if (_ptr_dns_name) {
7691                         NDR_PULL_ALLOC(ndr, r->dns_name);
7692                 } else {
7693                         r->dns_name = NULL;
7694                 }
7695                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7696                 if (_ptr_site_name) {
7697                         NDR_PULL_ALLOC(ndr, r->site_name);
7698                 } else {
7699                         r->site_name = NULL;
7700                 }
7701                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7702                 if (_ptr_site_dn) {
7703                         NDR_PULL_ALLOC(ndr, r->site_dn);
7704                 } else {
7705                         r->site_dn = NULL;
7706                 }
7707                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7708                 if (_ptr_computer_dn) {
7709                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7710                 } else {
7711                         r->computer_dn = NULL;
7712                 }
7713                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7714                 if (_ptr_server_dn) {
7715                         NDR_PULL_ALLOC(ndr, r->server_dn);
7716                 } else {
7717                         r->server_dn = NULL;
7718                 }
7719                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7720                 if (_ptr_ntds_dn) {
7721                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7722                 } else {
7723                         r->ntds_dn = NULL;
7724                 }
7725                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7727                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7728                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_rodc));
7729                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7730                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7731                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7732                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7733                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7734         }
7735         if (ndr_flags & NDR_BUFFERS) {
7736                 if (r->netbios_name) {
7737                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7738                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7739                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7740                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7741                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7742                                 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));
7743                         }
7744                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7745                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7746                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7747                 }
7748                 if (r->dns_name) {
7749                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7750                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7751                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7752                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7753                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7754                                 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));
7755                         }
7756                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7757                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7758                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7759                 }
7760                 if (r->site_name) {
7761                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7762                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7763                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7764                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7765                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7766                                 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));
7767                         }
7768                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7769                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7770                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7771                 }
7772                 if (r->site_dn) {
7773                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7774                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7775                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7776                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7777                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7778                                 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));
7779                         }
7780                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7781                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7782                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7783                 }
7784                 if (r->computer_dn) {
7785                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7786                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7787                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7788                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7789                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7790                                 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));
7791                         }
7792                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7793                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7794                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7795                 }
7796                 if (r->server_dn) {
7797                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7798                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7799                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7800                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7801                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7802                                 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));
7803                         }
7804                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7805                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7806                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7807                 }
7808                 if (r->ntds_dn) {
7809                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7810                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7811                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7812                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7813                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7814                                 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));
7815                         }
7816                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7817                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7818                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7819                 }
7820         }
7821         return NDR_ERR_SUCCESS;
7822 }
7823
7824 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo3 *r)
7825 {
7826         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo3");
7827         ndr->depth++;
7828         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7829         ndr->depth++;
7830         if (r->netbios_name) {
7831                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7832         }
7833         ndr->depth--;
7834         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7835         ndr->depth++;
7836         if (r->dns_name) {
7837                 ndr_print_string(ndr, "dns_name", r->dns_name);
7838         }
7839         ndr->depth--;
7840         ndr_print_ptr(ndr, "site_name", r->site_name);
7841         ndr->depth++;
7842         if (r->site_name) {
7843                 ndr_print_string(ndr, "site_name", r->site_name);
7844         }
7845         ndr->depth--;
7846         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7847         ndr->depth++;
7848         if (r->site_dn) {
7849                 ndr_print_string(ndr, "site_dn", r->site_dn);
7850         }
7851         ndr->depth--;
7852         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7853         ndr->depth++;
7854         if (r->computer_dn) {
7855                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7856         }
7857         ndr->depth--;
7858         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7859         ndr->depth++;
7860         if (r->server_dn) {
7861                 ndr_print_string(ndr, "server_dn", r->server_dn);
7862         }
7863         ndr->depth--;
7864         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7865         ndr->depth++;
7866         if (r->ntds_dn) {
7867                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7868         }
7869         ndr->depth--;
7870         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7871         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7872         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7873         ndr_print_uint32(ndr, "is_rodc", r->is_rodc);
7874         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7875         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7876         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7877         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7878         ndr->depth--;
7879 }
7880
7881 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr3 *r)
7882 {
7883         uint32_t cntr_array_1;
7884         if (ndr_flags & NDR_SCALARS) {
7885                 NDR_CHECK(ndr_push_align(ndr, 5));
7886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7887                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7888                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7889         }
7890         if (ndr_flags & NDR_BUFFERS) {
7891                 if (r->array) {
7892                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7893                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7894                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7895                         }
7896                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7897                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7898                         }
7899                 }
7900         }
7901         return NDR_ERR_SUCCESS;
7902 }
7903
7904 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr3 *r)
7905 {
7906         uint32_t _ptr_array;
7907         uint32_t cntr_array_1;
7908         TALLOC_CTX *_mem_save_array_0;
7909         TALLOC_CTX *_mem_save_array_1;
7910         if (ndr_flags & NDR_SCALARS) {
7911                 NDR_CHECK(ndr_pull_align(ndr, 5));
7912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7913                 if (r->count > 10000) {
7914                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7915                 }
7916                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7917                 if (_ptr_array) {
7918                         NDR_PULL_ALLOC(ndr, r->array);
7919                 } else {
7920                         r->array = NULL;
7921                 }
7922                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7923         }
7924         if (ndr_flags & NDR_BUFFERS) {
7925                 if (r->array) {
7926                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7927                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7928                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7929                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7930                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7931                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7932                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7933                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7934                         }
7935                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7936                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7937                         }
7938                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7939                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7940                 }
7941                 if (r->array) {
7942                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7943                 }
7944         }
7945         return NDR_ERR_SUCCESS;
7946 }
7947
7948 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr3 *r)
7949 {
7950         uint32_t cntr_array_1;
7951         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr3");
7952         ndr->depth++;
7953         ndr_print_uint32(ndr, "count", r->count);
7954         ndr_print_ptr(ndr, "array", r->array);
7955         ndr->depth++;
7956         if (r->array) {
7957                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7958                 ndr->depth++;
7959                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7960                         char *idx_1=NULL;
7961                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7962                                 ndr_print_drsuapi_DsGetDCInfo3(ndr, "array", &r->array[cntr_array_1]);
7963                                 free(idx_1);
7964                         }
7965                 }
7966                 ndr->depth--;
7967         }
7968         ndr->depth--;
7969         ndr->depth--;
7970 }
7971
7972 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnection01 *r)
7973 {
7974         if (ndr_flags & NDR_SCALARS) {
7975                 NDR_CHECK(ndr_push_align(ndr, 5));
7976                 {
7977                         uint32_t _flags_save_ipv4address = ndr->flags;
7978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
7979                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
7980                         ndr->flags = _flags_save_ipv4address;
7981                 }
7982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
7983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connection_time));
7984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
7985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
7986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
7987                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
7988                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7989         }
7990         if (ndr_flags & NDR_BUFFERS) {
7991                 if (r->client_account) {
7992                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7993                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7994                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7995                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_account, ndr_charset_length(r->client_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7996                 }
7997         }
7998         return NDR_ERR_SUCCESS;
7999 }
8000
8001 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnection01 *r)
8002 {
8003         uint32_t _ptr_client_account;
8004         TALLOC_CTX *_mem_save_client_account_0;
8005         if (ndr_flags & NDR_SCALARS) {
8006                 NDR_CHECK(ndr_pull_align(ndr, 5));
8007                 {
8008                         uint32_t _flags_save_ipv4address = ndr->flags;
8009                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
8010                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
8011                         ndr->flags = _flags_save_ipv4address;
8012                 }
8013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connection_time));
8015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
8016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
8017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
8018                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_account));
8019                 if (_ptr_client_account) {
8020                         NDR_PULL_ALLOC(ndr, r->client_account);
8021                 } else {
8022                         r->client_account = NULL;
8023                 }
8024                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8025         }
8026         if (ndr_flags & NDR_BUFFERS) {
8027                 if (r->client_account) {
8028                         _mem_save_client_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8029                         NDR_PULL_SET_MEM_CTX(ndr, r->client_account, 0);
8030                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_account));
8031                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_account));
8032                         if (ndr_get_array_length(ndr, &r->client_account) > ndr_get_array_size(ndr, &r->client_account)) {
8033                                 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));
8034                         }
8035                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t)));
8036                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t), CH_UTF16));
8037                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_account_0, 0);
8038                 }
8039         }
8040         return NDR_ERR_SUCCESS;
8041 }
8042
8043 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnection01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnection01 *r)
8044 {
8045         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnection01");
8046         ndr->depth++;
8047         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
8048         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8049         ndr_print_uint32(ndr, "connection_time", r->connection_time);
8050         ndr_print_uint32(ndr, "unknown4", r->unknown4);
8051         ndr_print_uint32(ndr, "unknown5", r->unknown5);
8052         ndr_print_uint32(ndr, "unknown6", r->unknown6);
8053         ndr_print_ptr(ndr, "client_account", r->client_account);
8054         ndr->depth++;
8055         if (r->client_account) {
8056                 ndr_print_string(ndr, "client_account", r->client_account);
8057         }
8058         ndr->depth--;
8059         ndr->depth--;
8060 }
8061
8062 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8063 {
8064         uint32_t cntr_array_1;
8065         if (ndr_flags & NDR_SCALARS) {
8066                 NDR_CHECK(ndr_push_align(ndr, 5));
8067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8068                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
8069                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8070         }
8071         if (ndr_flags & NDR_BUFFERS) {
8072                 if (r->array) {
8073                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
8074                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8075                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8076                         }
8077                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8078                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8079                         }
8080                 }
8081         }
8082         return NDR_ERR_SUCCESS;
8083 }
8084
8085 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnectionCtr01 *r)
8086 {
8087         uint32_t _ptr_array;
8088         uint32_t cntr_array_1;
8089         TALLOC_CTX *_mem_save_array_0;
8090         TALLOC_CTX *_mem_save_array_1;
8091         if (ndr_flags & NDR_SCALARS) {
8092                 NDR_CHECK(ndr_pull_align(ndr, 5));
8093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8094                 if (r->count > 10000) {
8095                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8096                 }
8097                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
8098                 if (_ptr_array) {
8099                         NDR_PULL_ALLOC(ndr, r->array);
8100                 } else {
8101                         r->array = NULL;
8102                 }
8103                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8104         }
8105         if (ndr_flags & NDR_BUFFERS) {
8106                 if (r->array) {
8107                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
8108                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8109                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
8110                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
8111                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
8112                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8113                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8114                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8115                         }
8116                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8117                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8118                         }
8119                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
8120                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
8121                 }
8122                 if (r->array) {
8123                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
8124                 }
8125         }
8126         return NDR_ERR_SUCCESS;
8127 }
8128
8129 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnectionCtr01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8130 {
8131         uint32_t cntr_array_1;
8132         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnectionCtr01");
8133         ndr->depth++;
8134         ndr_print_uint32(ndr, "count", r->count);
8135         ndr_print_ptr(ndr, "array", r->array);
8136         ndr->depth++;
8137         if (r->array) {
8138                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
8139                 ndr->depth++;
8140                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
8141                         char *idx_1=NULL;
8142                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8143                                 ndr_print_drsuapi_DsGetDCConnection01(ndr, "array", &r->array[cntr_array_1]);
8144                                 free(idx_1);
8145                         }
8146                 }
8147                 ndr->depth--;
8148         }
8149         ndr->depth--;
8150         ndr->depth--;
8151 }
8152
8153 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoCtr *r)
8154 {
8155         if (ndr_flags & NDR_SCALARS) {
8156                 int level = ndr_push_get_switch_value(ndr, r);
8157                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8158                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8159                 switch (level) {
8160                         case DRSUAPI_DC_INFO_CTR_1: {
8161                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8162                         break; }
8163
8164                         case DRSUAPI_DC_INFO_CTR_2: {
8165                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8166                         break; }
8167
8168                         case DRSUAPI_DC_INFO_CTR_3: {
8169                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8170                         break; }
8171
8172                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8173                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8174                         break; }
8175
8176                         default:
8177                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8178                 }
8179         }
8180         if (ndr_flags & NDR_BUFFERS) {
8181                 int level = ndr_push_get_switch_value(ndr, r);
8182                 switch (level) {
8183                         case DRSUAPI_DC_INFO_CTR_1:
8184                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8185                         break;
8186
8187                         case DRSUAPI_DC_INFO_CTR_2:
8188                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8189                         break;
8190
8191                         case DRSUAPI_DC_INFO_CTR_3:
8192                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8193                         break;
8194
8195                         case DRSUAPI_DC_CONNECTION_CTR_01:
8196                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8197                         break;
8198
8199                         default:
8200                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8201                 }
8202         }
8203         return NDR_ERR_SUCCESS;
8204 }
8205
8206 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoCtr *r)
8207 {
8208         int level;
8209         int32_t _level;
8210         level = ndr_pull_get_switch_value(ndr, r);
8211         if (ndr_flags & NDR_SCALARS) {
8212                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8213                 if (_level != level) {
8214                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8215                 }
8216                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8217                 switch (level) {
8218                         case DRSUAPI_DC_INFO_CTR_1: {
8219                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8220                         break; }
8221
8222                         case DRSUAPI_DC_INFO_CTR_2: {
8223                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8224                         break; }
8225
8226                         case DRSUAPI_DC_INFO_CTR_3: {
8227                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8228                         break; }
8229
8230                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8231                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8232                         break; }
8233
8234                         default:
8235                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8236                 }
8237         }
8238         if (ndr_flags & NDR_BUFFERS) {
8239                 switch (level) {
8240                         case DRSUAPI_DC_INFO_CTR_1:
8241                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8242                         break;
8243
8244                         case DRSUAPI_DC_INFO_CTR_2:
8245                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8246                         break;
8247
8248                         case DRSUAPI_DC_INFO_CTR_3:
8249                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8250                         break;
8251
8252                         case DRSUAPI_DC_CONNECTION_CTR_01:
8253                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8254                         break;
8255
8256                         default:
8257                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8258                 }
8259         }
8260         return NDR_ERR_SUCCESS;
8261 }
8262
8263 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoCtr *r)
8264 {
8265         int level;
8266         level = ndr_print_get_switch_value(ndr, r);
8267         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoCtr");
8268         switch (level) {
8269                 case DRSUAPI_DC_INFO_CTR_1:
8270                         ndr_print_drsuapi_DsGetDCInfoCtr1(ndr, "ctr1", &r->ctr1);
8271                 break;
8272
8273                 case DRSUAPI_DC_INFO_CTR_2:
8274                         ndr_print_drsuapi_DsGetDCInfoCtr2(ndr, "ctr2", &r->ctr2);
8275                 break;
8276
8277                 case DRSUAPI_DC_INFO_CTR_3:
8278                         ndr_print_drsuapi_DsGetDCInfoCtr3(ndr, "ctr3", &r->ctr3);
8279                 break;
8280
8281                 case DRSUAPI_DC_CONNECTION_CTR_01:
8282                         ndr_print_drsuapi_DsGetDCConnectionCtr01(ndr, "ctr01", &r->ctr01);
8283                 break;
8284
8285                 default:
8286                         ndr_print_bad_level(ndr, name, level);
8287         }
8288 }
8289
8290 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItem *r)
8291 {
8292         if (ndr_flags & NDR_SCALARS) {
8293                 NDR_CHECK(ndr_push_align(ndr, 5));
8294                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
8295                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8296                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8297         }
8298         if (ndr_flags & NDR_BUFFERS) {
8299                 if (r->next_object) {
8300                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8301                 }
8302                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8303         }
8304         return NDR_ERR_SUCCESS;
8305 }
8306
8307 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItem *r)
8308 {
8309         uint32_t _ptr_next_object;
8310         TALLOC_CTX *_mem_save_next_object_0;
8311         if (ndr_flags & NDR_SCALARS) {
8312                 NDR_CHECK(ndr_pull_align(ndr, 5));
8313                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
8314                 if (_ptr_next_object) {
8315                         NDR_PULL_ALLOC(ndr, r->next_object);
8316                 } else {
8317                         r->next_object = NULL;
8318                 }
8319                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8320                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8321         }
8322         if (ndr_flags & NDR_BUFFERS) {
8323                 if (r->next_object) {
8324                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
8325                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
8326                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8327                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
8328                 }
8329                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8330         }
8331         return NDR_ERR_SUCCESS;
8332 }
8333
8334 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryRequest2 *r)
8335 {
8336         if (ndr_flags & NDR_SCALARS) {
8337                 NDR_CHECK(ndr_push_align(ndr, 5));
8338                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8339                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8340         }
8341         if (ndr_flags & NDR_BUFFERS) {
8342                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8343         }
8344         return NDR_ERR_SUCCESS;
8345 }
8346
8347 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryRequest2 *r)
8348 {
8349         if (ndr_flags & NDR_SCALARS) {
8350                 NDR_CHECK(ndr_pull_align(ndr, 5));
8351                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8352                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8353         }
8354         if (ndr_flags & NDR_BUFFERS) {
8355                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8356         }
8357         return NDR_ERR_SUCCESS;
8358 }
8359
8360 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryRequest2 *r)
8361 {
8362         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryRequest2");
8363         ndr->depth++;
8364         ndr_print_drsuapi_DsReplicaObjectListItem(ndr, "first_object", &r->first_object);
8365         ndr->depth--;
8366 }
8367
8368 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryRequest *r)
8369 {
8370         if (ndr_flags & NDR_SCALARS) {
8371                 int level = ndr_push_get_switch_value(ndr, r);
8372                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8373                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8374                 switch (level) {
8375                         case 2: {
8376                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8377                         break; }
8378
8379                         default:
8380                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8381                 }
8382         }
8383         if (ndr_flags & NDR_BUFFERS) {
8384                 int level = ndr_push_get_switch_value(ndr, r);
8385                 switch (level) {
8386                         case 2:
8387                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8388                         break;
8389
8390                         default:
8391                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8392                 }
8393         }
8394         return NDR_ERR_SUCCESS;
8395 }
8396
8397 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryRequest *r)
8398 {
8399         int level;
8400         int32_t _level;
8401         level = ndr_pull_get_switch_value(ndr, r);
8402         if (ndr_flags & NDR_SCALARS) {
8403                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8404                 if (_level != level) {
8405                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8406                 }
8407                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8408                 switch (level) {
8409                         case 2: {
8410                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8411                         break; }
8412
8413                         default:
8414                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8415                 }
8416         }
8417         if (ndr_flags & NDR_BUFFERS) {
8418                 switch (level) {
8419                         case 2:
8420                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8421                         break;
8422
8423                         default:
8424                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8425                 }
8426         }
8427         return NDR_ERR_SUCCESS;
8428 }
8429
8430 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryRequest *r)
8431 {
8432         int level;
8433         level = ndr_print_get_switch_value(ndr, r);
8434         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryRequest");
8435         switch (level) {
8436                 case 2:
8437                         ndr_print_drsuapi_DsAddEntryRequest2(ndr, "req2", &r->req2);
8438                 break;
8439
8440                 default:
8441                         ndr_print_bad_level(ndr, name, level);
8442         }
8443 }
8444
8445 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfoX *r)
8446 {
8447         if (ndr_flags & NDR_SCALARS) {
8448                 NDR_CHECK(ndr_push_align(ndr, 4));
8449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8450                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8452                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
8453                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8454         }
8455         if (ndr_flags & NDR_BUFFERS) {
8456         }
8457         return NDR_ERR_SUCCESS;
8458 }
8459
8460 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfoX *r)
8461 {
8462         if (ndr_flags & NDR_SCALARS) {
8463                 NDR_CHECK(ndr_pull_align(ndr, 4));
8464                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8465                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8467                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
8468                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8469         }
8470         if (ndr_flags & NDR_BUFFERS) {
8471         }
8472         return NDR_ERR_SUCCESS;
8473 }
8474
8475 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfoX(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfoX *r)
8476 {
8477         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfoX");
8478         ndr->depth++;
8479         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8480         ndr_print_WERROR(ndr, "status", r->status);
8481         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8482         ndr_print_uint16(ndr, "unknown3", r->unknown3);
8483         ndr->depth--;
8484 }
8485
8486 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8487 {
8488         if (ndr_flags & NDR_SCALARS) {
8489                 NDR_CHECK(ndr_push_align(ndr, 5));
8490                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8491                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
8492                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8493         }
8494         if (ndr_flags & NDR_BUFFERS) {
8495                 if (r->data) {
8496                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size));
8497                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
8498                 }
8499         }
8500         return NDR_ERR_SUCCESS;
8501 }
8502
8503 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8504 {
8505         uint32_t _ptr_data;
8506         TALLOC_CTX *_mem_save_data_0;
8507         if (ndr_flags & NDR_SCALARS) {
8508                 NDR_CHECK(ndr_pull_align(ndr, 5));
8509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8510                 if (r->size > 10485760) {
8511                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8512                 }
8513                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
8514                 if (_ptr_data) {
8515                         NDR_PULL_ALLOC(ndr, r->data);
8516                 } else {
8517                         r->data = NULL;
8518                 }
8519                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8520         }
8521         if (ndr_flags & NDR_BUFFERS) {
8522                 if (r->data) {
8523                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
8524                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
8525                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
8526                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
8527                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
8528                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
8529                 }
8530                 if (r->data) {
8531                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
8532                 }
8533         }
8534         return NDR_ERR_SUCCESS;
8535 }
8536
8537 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8538 {
8539         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraErrorBuffer");
8540         ndr->depth++;
8541         ndr_print_uint32(ndr, "size", r->size);
8542         ndr_print_ptr(ndr, "data", r->data);
8543         ndr->depth++;
8544         if (r->data) {
8545                 ndr_print_array_uint8(ndr, "data", r->data, r->size);
8546         }
8547         ndr->depth--;
8548         ndr->depth--;
8549 }
8550
8551 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraError1 *r)
8552 {
8553         if (ndr_flags & NDR_SCALARS) {
8554                 NDR_CHECK(ndr_push_align(ndr, 5));
8555                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8556                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
8557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8558                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8559                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8560         }
8561         if (ndr_flags & NDR_BUFFERS) {
8562                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8563         }
8564         return NDR_ERR_SUCCESS;
8565 }
8566
8567 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraError1 *r)
8568 {
8569         if (ndr_flags & NDR_SCALARS) {
8570                 NDR_CHECK(ndr_pull_align(ndr, 5));
8571                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8572                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
8573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8574                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8575                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8576         }
8577         if (ndr_flags & NDR_BUFFERS) {
8578                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8579         }
8580         return NDR_ERR_SUCCESS;
8581 }
8582
8583 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraError1 *r)
8584 {
8585         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraError1");
8586         ndr->depth++;
8587         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8588         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
8589         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8590         ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(ndr, "buffer", &r->buffer);
8591         ndr->depth--;
8592 }
8593
8594 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8595 {
8596         if (ndr_flags & NDR_SCALARS) {
8597                 NDR_CHECK(ndr_push_align(ndr, 5));
8598                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
8599                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8600                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8601         }
8602         if (ndr_flags & NDR_BUFFERS) {
8603                 if (r->next) {
8604                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8605                 }
8606                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8607         }
8608         return NDR_ERR_SUCCESS;
8609 }
8610
8611 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorListItem1 *r)
8612 {
8613         uint32_t _ptr_next;
8614         TALLOC_CTX *_mem_save_next_0;
8615         if (ndr_flags & NDR_SCALARS) {
8616                 NDR_CHECK(ndr_pull_align(ndr, 5));
8617                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
8618                 if (_ptr_next) {
8619                         NDR_PULL_ALLOC(ndr, r->next);
8620                 } else {
8621                         r->next = NULL;
8622                 }
8623                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8624                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8625         }
8626         if (ndr_flags & NDR_BUFFERS) {
8627                 if (r->next) {
8628                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
8629                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
8630                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8631                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
8632                 }
8633                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8634         }
8635         return NDR_ERR_SUCCESS;
8636 }
8637
8638 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorListItem1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8639 {
8640         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorListItem1");
8641         ndr->depth++;
8642         ndr_print_ptr(ndr, "next", r->next);
8643         ndr->depth++;
8644         if (r->next) {
8645                 ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "next", r->next);
8646         }
8647         ndr->depth--;
8648         ndr_print_drsuapi_DsAddEntryExtraError1(ndr, "error", &r->error);
8649         ndr->depth--;
8650 }
8651
8652 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8653 {
8654         if (ndr_flags & NDR_SCALARS) {
8655                 NDR_CHECK(ndr_push_align(ndr, 5));
8656                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8657                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8658                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8659                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8660         }
8661         if (ndr_flags & NDR_BUFFERS) {
8662                 if (r->id) {
8663                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8664                 }
8665                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8666         }
8667         return NDR_ERR_SUCCESS;
8668 }
8669
8670 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfo1 *r)
8671 {
8672         uint32_t _ptr_id;
8673         TALLOC_CTX *_mem_save_id_0;
8674         if (ndr_flags & NDR_SCALARS) {
8675                 NDR_CHECK(ndr_pull_align(ndr, 5));
8676                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8677                 if (_ptr_id) {
8678                         NDR_PULL_ALLOC(ndr, r->id);
8679                 } else {
8680                         r->id = NULL;
8681                 }
8682                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8683                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8684                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8685         }
8686         if (ndr_flags & NDR_BUFFERS) {
8687                 if (r->id) {
8688                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8689                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8690                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8691                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8692                 }
8693                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8694         }
8695         return NDR_ERR_SUCCESS;
8696 }
8697
8698 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8699 {
8700         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfo1");
8701         ndr->depth++;
8702         ndr_print_ptr(ndr, "id", r->id);
8703         ndr->depth++;
8704         if (r->id) {
8705                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8706         }
8707         ndr->depth--;
8708         ndr_print_WERROR(ndr, "status", r->status);
8709         ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "first", &r->first);
8710         ndr->depth--;
8711 }
8712
8713 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryErrorInfo *r)
8714 {
8715         if (ndr_flags & NDR_SCALARS) {
8716                 int level = ndr_push_get_switch_value(ndr, r);
8717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8718                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8719                 switch (level) {
8720                         case 1: {
8721                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8722                         break; }
8723
8724                         case 4: {
8725                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8726                         break; }
8727
8728                         case 5: {
8729                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8730                         break; }
8731
8732                         case 6: {
8733                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8734                         break; }
8735
8736                         case 7: {
8737                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8738                         break; }
8739
8740                         default:
8741                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8742                 }
8743         }
8744         if (ndr_flags & NDR_BUFFERS) {
8745                 int level = ndr_push_get_switch_value(ndr, r);
8746                 switch (level) {
8747                         case 1:
8748                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8749                         break;
8750
8751                         case 4:
8752                         break;
8753
8754                         case 5:
8755                         break;
8756
8757                         case 6:
8758                         break;
8759
8760                         case 7:
8761                         break;
8762
8763                         default:
8764                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8765                 }
8766         }
8767         return NDR_ERR_SUCCESS;
8768 }
8769
8770 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryErrorInfo *r)
8771 {
8772         int level;
8773         uint32_t _level;
8774         level = ndr_pull_get_switch_value(ndr, r);
8775         if (ndr_flags & NDR_SCALARS) {
8776                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8777                 if (_level != level) {
8778                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8779                 }
8780                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8781                 switch (level) {
8782                         case 1: {
8783                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8784                         break; }
8785
8786                         case 4: {
8787                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8788                         break; }
8789
8790                         case 5: {
8791                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8792                         break; }
8793
8794                         case 6: {
8795                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8796                         break; }
8797
8798                         case 7: {
8799                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8800                         break; }
8801
8802                         default:
8803                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8804                 }
8805         }
8806         if (ndr_flags & NDR_BUFFERS) {
8807                 switch (level) {
8808                         case 1:
8809                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8810                         break;
8811
8812                         case 4:
8813                         break;
8814
8815                         case 5:
8816                         break;
8817
8818                         case 6:
8819                         break;
8820
8821                         case 7:
8822                         break;
8823
8824                         default:
8825                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8826                 }
8827         }
8828         return NDR_ERR_SUCCESS;
8829 }
8830
8831 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryErrorInfo *r)
8832 {
8833         int level;
8834         level = ndr_print_get_switch_value(ndr, r);
8835         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryErrorInfo");
8836         switch (level) {
8837                 case 1:
8838                         ndr_print_drsuapi_DsAddEntryErrorInfo1(ndr, "error1", &r->error1);
8839                 break;
8840
8841                 case 4:
8842                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8843                 break;
8844
8845                 case 5:
8846                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8847                 break;
8848
8849                 case 6:
8850                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8851                 break;
8852
8853                 case 7:
8854                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8855                 break;
8856
8857                 default:
8858                         ndr_print_bad_level(ndr, name, level);
8859         }
8860 }
8861
8862 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryError1 *r)
8863 {
8864         if (ndr_flags & NDR_SCALARS) {
8865                 NDR_CHECK(ndr_push_align(ndr, 5));
8866                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8868                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
8869                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8870         }
8871         if (ndr_flags & NDR_BUFFERS) {
8872                 if (r->info) {
8873                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->info, r->level));
8874                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8875                 }
8876         }
8877         return NDR_ERR_SUCCESS;
8878 }
8879
8880 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryError1 *r)
8881 {
8882         uint32_t _ptr_info;
8883         TALLOC_CTX *_mem_save_info_0;
8884         if (ndr_flags & NDR_SCALARS) {
8885                 NDR_CHECK(ndr_pull_align(ndr, 5));
8886                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8887                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8888                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8889                 if (_ptr_info) {
8890                         NDR_PULL_ALLOC(ndr, r->info);
8891                 } else {
8892                         r->info = NULL;
8893                 }
8894                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8895         }
8896         if (ndr_flags & NDR_BUFFERS) {
8897                 if (r->info) {
8898                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8899                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
8900                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->info, r->level));
8901                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8902                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8903                 }
8904         }
8905         return NDR_ERR_SUCCESS;
8906 }
8907
8908 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryError1 *r)
8909 {
8910         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryError1");
8911         ndr->depth++;
8912         ndr_print_WERROR(ndr, "status", r->status);
8913         ndr_print_uint32(ndr, "level", r->level);
8914         ndr_print_ptr(ndr, "info", r->info);
8915         ndr->depth++;
8916         if (r->info) {
8917                 ndr_print_set_switch_value(ndr, r->info, r->level);
8918                 ndr_print_drsuapi_DsAddEntryErrorInfo(ndr, "info", r->info);
8919         }
8920         ndr->depth--;
8921         ndr->depth--;
8922 }
8923
8924 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryError *r)
8925 {
8926         if (ndr_flags & NDR_SCALARS) {
8927                 int level = ndr_push_get_switch_value(ndr, r);
8928                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8929                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8930                 switch (level) {
8931                         case 1: {
8932                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8933                         break; }
8934
8935                         default:
8936                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8937                 }
8938         }
8939         if (ndr_flags & NDR_BUFFERS) {
8940                 int level = ndr_push_get_switch_value(ndr, r);
8941                 switch (level) {
8942                         case 1:
8943                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8944                         break;
8945
8946                         default:
8947                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8948                 }
8949         }
8950         return NDR_ERR_SUCCESS;
8951 }
8952
8953 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryError *r)
8954 {
8955         int level;
8956         uint32_t _level;
8957         level = ndr_pull_get_switch_value(ndr, r);
8958         if (ndr_flags & NDR_SCALARS) {
8959                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8960                 if (_level != level) {
8961                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8962                 }
8963                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8964                 switch (level) {
8965                         case 1: {
8966                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8967                         break; }
8968
8969                         default:
8970                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8971                 }
8972         }
8973         if (ndr_flags & NDR_BUFFERS) {
8974                 switch (level) {
8975                         case 1:
8976                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8977                         break;
8978
8979                         default:
8980                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8981                 }
8982         }
8983         return NDR_ERR_SUCCESS;
8984 }
8985
8986 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryError *r)
8987 {
8988         int level;
8989         level = ndr_print_get_switch_value(ndr, r);
8990         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryError");
8991         switch (level) {
8992                 case 1:
8993                         ndr_print_drsuapi_DsAddEntryError1(ndr, "info1", &r->info1);
8994                 break;
8995
8996                 default:
8997                         ndr_print_bad_level(ndr, name, level);
8998         }
8999 }
9000
9001 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9002 {
9003         if (ndr_flags & NDR_SCALARS) {
9004                 NDR_CHECK(ndr_push_align(ndr, 4));
9005                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
9006                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9007                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9008         }
9009         if (ndr_flags & NDR_BUFFERS) {
9010                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9011         }
9012         return NDR_ERR_SUCCESS;
9013 }
9014
9015 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier2 *r)
9016 {
9017         if (ndr_flags & NDR_SCALARS) {
9018                 NDR_CHECK(ndr_pull_align(ndr, 4));
9019                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
9020                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9021                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9022         }
9023         if (ndr_flags & NDR_BUFFERS) {
9024                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9025         }
9026         return NDR_ERR_SUCCESS;
9027 }
9028
9029 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9030 {
9031         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier2");
9032         ndr->depth++;
9033         ndr_print_GUID(ndr, "guid", &r->guid);
9034         ndr_print_dom_sid28(ndr, "sid", &r->sid);
9035         ndr->depth--;
9036 }
9037
9038 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr2 *r)
9039 {
9040         uint32_t cntr_objects_1;
9041         if (ndr_flags & NDR_SCALARS) {
9042                 NDR_CHECK(ndr_push_align(ndr, 5));
9043                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9045                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9047                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9048                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9049         }
9050         if (ndr_flags & NDR_BUFFERS) {
9051                 if (r->id) {
9052                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9053                 }
9054                 if (r->objects) {
9055                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9056                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9057                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9058                         }
9059                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9060                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9061                         }
9062                 }
9063         }
9064         return NDR_ERR_SUCCESS;
9065 }
9066
9067 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr2 *r)
9068 {
9069         uint32_t _ptr_id;
9070         TALLOC_CTX *_mem_save_id_0;
9071         uint32_t _ptr_objects;
9072         uint32_t cntr_objects_1;
9073         TALLOC_CTX *_mem_save_objects_0;
9074         TALLOC_CTX *_mem_save_objects_1;
9075         if (ndr_flags & NDR_SCALARS) {
9076                 NDR_CHECK(ndr_pull_align(ndr, 5));
9077                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9078                 if (_ptr_id) {
9079                         NDR_PULL_ALLOC(ndr, r->id);
9080                 } else {
9081                         r->id = NULL;
9082                 }
9083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9084                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9086                 if (r->count > 10000) {
9087                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9088                 }
9089                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9090                 if (_ptr_objects) {
9091                         NDR_PULL_ALLOC(ndr, r->objects);
9092                 } else {
9093                         r->objects = NULL;
9094                 }
9095                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9096         }
9097         if (ndr_flags & NDR_BUFFERS) {
9098                 if (r->id) {
9099                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9100                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9101                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9102                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9103                 }
9104                 if (r->objects) {
9105                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9106                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9107                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9108                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9109                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9110                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9111                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9112                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9113                         }
9114                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9115                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9116                         }
9117                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9118                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9119                 }
9120                 if (r->objects) {
9121                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9122                 }
9123         }
9124         return NDR_ERR_SUCCESS;
9125 }
9126
9127 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr2 *r)
9128 {
9129         uint32_t cntr_objects_1;
9130         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr2");
9131         ndr->depth++;
9132         ndr_print_ptr(ndr, "id", r->id);
9133         ndr->depth++;
9134         if (r->id) {
9135                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9136         }
9137         ndr->depth--;
9138         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9139         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
9140         ndr_print_uint32(ndr, "count", r->count);
9141         ndr_print_ptr(ndr, "objects", r->objects);
9142         ndr->depth++;
9143         if (r->objects) {
9144                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9145                 ndr->depth++;
9146                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9147                         char *idx_1=NULL;
9148                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9149                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9150                                 free(idx_1);
9151                         }
9152                 }
9153                 ndr->depth--;
9154         }
9155         ndr->depth--;
9156         ndr->depth--;
9157 }
9158
9159 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr3 *r)
9160 {
9161         uint32_t cntr_objects_1;
9162         if (ndr_flags & NDR_SCALARS) {
9163                 NDR_CHECK(ndr_push_align(ndr, 5));
9164                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9166                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
9167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9168                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9169                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9170         }
9171         if (ndr_flags & NDR_BUFFERS) {
9172                 if (r->id) {
9173                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9174                 }
9175                 if (r->error) {
9176                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->error, r->level));
9177                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9178                 }
9179                 if (r->objects) {
9180                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9181                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9182                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9183                         }
9184                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9185                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9186                         }
9187                 }
9188         }
9189         return NDR_ERR_SUCCESS;
9190 }
9191
9192 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr3 *r)
9193 {
9194         uint32_t _ptr_id;
9195         TALLOC_CTX *_mem_save_id_0;
9196         uint32_t _ptr_error;
9197         TALLOC_CTX *_mem_save_error_0;
9198         uint32_t _ptr_objects;
9199         uint32_t cntr_objects_1;
9200         TALLOC_CTX *_mem_save_objects_0;
9201         TALLOC_CTX *_mem_save_objects_1;
9202         if (ndr_flags & NDR_SCALARS) {
9203                 NDR_CHECK(ndr_pull_align(ndr, 5));
9204                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9205                 if (_ptr_id) {
9206                         NDR_PULL_ALLOC(ndr, r->id);
9207                 } else {
9208                         r->id = NULL;
9209                 }
9210                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9211                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_error));
9212                 if (_ptr_error) {
9213                         NDR_PULL_ALLOC(ndr, r->error);
9214                 } else {
9215                         r->error = NULL;
9216                 }
9217                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9218                 if (r->count > 10000) {
9219                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9220                 }
9221                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9222                 if (_ptr_objects) {
9223                         NDR_PULL_ALLOC(ndr, r->objects);
9224                 } else {
9225                         r->objects = NULL;
9226                 }
9227                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9228         }
9229         if (ndr_flags & NDR_BUFFERS) {
9230                 if (r->id) {
9231                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9232                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9233                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9234                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9235                 }
9236                 if (r->error) {
9237                         _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
9238                         NDR_PULL_SET_MEM_CTX(ndr, r->error, 0);
9239                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->error, r->level));
9240                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9241                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, 0);
9242                 }
9243                 if (r->objects) {
9244                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9245                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9246                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9247                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9248                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9249                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9250                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9251                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9252                         }
9253                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9254                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9255                         }
9256                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9257                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9258                 }
9259                 if (r->objects) {
9260                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9261                 }
9262         }
9263         return NDR_ERR_SUCCESS;
9264 }
9265
9266 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr3 *r)
9267 {
9268         uint32_t cntr_objects_1;
9269         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr3");
9270         ndr->depth++;
9271         ndr_print_ptr(ndr, "id", r->id);
9272         ndr->depth++;
9273         if (r->id) {
9274                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9275         }
9276         ndr->depth--;
9277         ndr_print_uint32(ndr, "level", r->level);
9278         ndr_print_ptr(ndr, "error", r->error);
9279         ndr->depth++;
9280         if (r->error) {
9281                 ndr_print_set_switch_value(ndr, r->error, r->level);
9282                 ndr_print_drsuapi_DsAddEntryError(ndr, "error", r->error);
9283         }
9284         ndr->depth--;
9285         ndr_print_uint32(ndr, "count", r->count);
9286         ndr_print_ptr(ndr, "objects", r->objects);
9287         ndr->depth++;
9288         if (r->objects) {
9289                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9290                 ndr->depth++;
9291                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9292                         char *idx_1=NULL;
9293                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9294                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9295                                 free(idx_1);
9296                         }
9297                 }
9298                 ndr->depth--;
9299         }
9300         ndr->depth--;
9301         ndr->depth--;
9302 }
9303
9304 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryCtr *r)
9305 {
9306         if (ndr_flags & NDR_SCALARS) {
9307                 int level = ndr_push_get_switch_value(ndr, r);
9308                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
9309                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9310                 switch (level) {
9311                         case 2: {
9312                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9313                         break; }
9314
9315                         case 3: {
9316                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9317                         break; }
9318
9319                         default:
9320                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9321                 }
9322         }
9323         if (ndr_flags & NDR_BUFFERS) {
9324                 int level = ndr_push_get_switch_value(ndr, r);
9325                 switch (level) {
9326                         case 2:
9327                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9328                         break;
9329
9330                         case 3:
9331                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9332                         break;
9333
9334                         default:
9335                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9336                 }
9337         }
9338         return NDR_ERR_SUCCESS;
9339 }
9340
9341 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryCtr *r)
9342 {
9343         int level;
9344         int32_t _level;
9345         level = ndr_pull_get_switch_value(ndr, r);
9346         if (ndr_flags & NDR_SCALARS) {
9347                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
9348                 if (_level != level) {
9349                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9350                 }
9351                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9352                 switch (level) {
9353                         case 2: {
9354                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9355                         break; }
9356
9357                         case 3: {
9358                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9359                         break; }
9360
9361                         default:
9362                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9363                 }
9364         }
9365         if (ndr_flags & NDR_BUFFERS) {
9366                 switch (level) {
9367                         case 2:
9368                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9369                         break;
9370
9371                         case 3:
9372                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9373                         break;
9374
9375                         default:
9376                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9377                 }
9378         }
9379         return NDR_ERR_SUCCESS;
9380 }
9381
9382 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
9383 {
9384         int level;
9385         level = ndr_print_get_switch_value(ndr, r);
9386         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
9387         switch (level) {
9388                 case 2:
9389                         ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
9390                 break;
9391
9392                 case 3:
9393                         ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
9394                 break;
9395
9396                 default:
9397                         ndr_print_bad_level(ndr, name, level);
9398         }
9399 }
9400
9401 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9402 {
9403         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9404         return NDR_ERR_SUCCESS;
9405 }
9406
9407 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9408 {
9409         uint32_t v;
9410         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9411         *r = v;
9412         return NDR_ERR_SUCCESS;
9413 }
9414
9415 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCFlags(struct ndr_print *ndr, const char *name, uint32_t r)
9416 {
9417         ndr_print_uint32(ndr, name, r);
9418         ndr->depth++;
9419         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION, r);
9420         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_DAMPED", DRSUAPI_DS_EXECUTE_KCC_DAMPED, r);
9421         ndr->depth--;
9422 }
9423
9424 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsExecuteKCC1 *r)
9425 {
9426         if (ndr_flags & NDR_SCALARS) {
9427                 NDR_CHECK(ndr_push_align(ndr, 4));
9428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->taskID));
9429                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, r->flags));
9430                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9431         }
9432         if (ndr_flags & NDR_BUFFERS) {
9433         }
9434         return NDR_ERR_SUCCESS;
9435 }
9436
9437 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsExecuteKCC1 *r)
9438 {
9439         if (ndr_flags & NDR_SCALARS) {
9440                 NDR_CHECK(ndr_pull_align(ndr, 4));
9441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->taskID));
9442                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, &r->flags));
9443                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9444         }
9445         if (ndr_flags & NDR_BUFFERS) {
9446         }
9447         return NDR_ERR_SUCCESS;
9448 }
9449
9450 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsExecuteKCC1 *r)
9451 {
9452         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC1");
9453         ndr->depth++;
9454         ndr_print_uint32(ndr, "taskID", r->taskID);
9455         ndr_print_drsuapi_DsExecuteKCCFlags(ndr, "flags", r->flags);
9456         ndr->depth--;
9457 }
9458
9459 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsExecuteKCCRequest *r)
9460 {
9461         if (ndr_flags & NDR_SCALARS) {
9462                 int level = ndr_push_get_switch_value(ndr, r);
9463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9464                 NDR_CHECK(ndr_push_union_align(ndr, 4));
9465                 switch (level) {
9466                         case 1: {
9467                                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9468                         break; }
9469
9470                         default:
9471                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9472                 }
9473         }
9474         if (ndr_flags & NDR_BUFFERS) {
9475                 int level = ndr_push_get_switch_value(ndr, r);
9476                 switch (level) {
9477                         case 1:
9478                         break;
9479
9480                         default:
9481                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9482                 }
9483         }
9484         return NDR_ERR_SUCCESS;
9485 }
9486
9487 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsExecuteKCCRequest *r)
9488 {
9489         int level;
9490         uint32_t _level;
9491         level = ndr_pull_get_switch_value(ndr, r);
9492         if (ndr_flags & NDR_SCALARS) {
9493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9494                 if (_level != level) {
9495                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9496                 }
9497                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
9498                 switch (level) {
9499                         case 1: {
9500                                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9501                         break; }
9502
9503                         default:
9504                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9505                 }
9506         }
9507         if (ndr_flags & NDR_BUFFERS) {
9508                 switch (level) {
9509                         case 1:
9510                         break;
9511
9512                         default:
9513                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9514                 }
9515         }
9516         return NDR_ERR_SUCCESS;
9517 }
9518
9519 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsExecuteKCCRequest *r)
9520 {
9521         int level;
9522         level = ndr_print_get_switch_value(ndr, r);
9523         ndr_print_union(ndr, name, level, "drsuapi_DsExecuteKCCRequest");
9524         switch (level) {
9525                 case 1:
9526                         ndr_print_drsuapi_DsExecuteKCC1(ndr, "ctr1", &r->ctr1);
9527                 break;
9528
9529                 default:
9530                         ndr_print_bad_level(ndr, name, level);
9531         }
9532 }
9533
9534 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
9535 {
9536         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9537         return NDR_ERR_SUCCESS;
9538 }
9539
9540 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
9541 {
9542         uint32_t v;
9543         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9544         *r = v;
9545         return NDR_ERR_SUCCESS;
9546 }
9547
9548 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaGetInfoLevel r)
9549 {
9550         const char *val = NULL;
9551
9552         switch (r) {
9553                 case DRSUAPI_DS_REPLICA_GET_INFO: val = "DRSUAPI_DS_REPLICA_GET_INFO"; break;
9554                 case DRSUAPI_DS_REPLICA_GET_INFO2: val = "DRSUAPI_DS_REPLICA_GET_INFO2"; break;
9555         }
9556         ndr_print_enum(ndr, name, "ENUM", val, r);
9557 }
9558
9559 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
9560 {
9561         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9562         return NDR_ERR_SUCCESS;
9563 }
9564
9565 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
9566 {
9567         uint32_t v;
9568         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9569         *r = v;
9570         return NDR_ERR_SUCCESS;
9571 }
9572
9573 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaInfoType r)
9574 {
9575         const char *val = NULL;
9576
9577         switch (r) {
9578                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS"; break;
9579                 case DRSUAPI_DS_REPLICA_INFO_CURSORS: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS"; break;
9580                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA"; break;
9581                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES"; break;
9582                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES"; break;
9583                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: val = "DRSUAPI_DS_REPLICA_INFO_PENDING_OPS"; break;
9584                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA"; break;
9585                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS2"; break;
9586                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS3"; break;
9587                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2"; break;
9588                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2"; break;
9589                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02"; break;
9590                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: val = "DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04"; break;
9591                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS05"; break;
9592                 case DRSUAPI_DS_REPLICA_INFO_06: val = "DRSUAPI_DS_REPLICA_INFO_06"; break;
9593         }
9594         ndr_print_enum(ndr, name, "ENUM", val, r);
9595 }
9596
9597 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9598 {
9599         if (ndr_flags & NDR_SCALARS) {
9600                 NDR_CHECK(ndr_push_align(ndr, 5));
9601                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9602                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9603                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9604                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9605         }
9606         if (ndr_flags & NDR_BUFFERS) {
9607                 if (r->object_dn) {
9608                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9609                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9610                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9611                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9612                 }
9613         }
9614         return NDR_ERR_SUCCESS;
9615 }
9616
9617 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
9618 {
9619         uint32_t _ptr_object_dn;
9620         TALLOC_CTX *_mem_save_object_dn_0;
9621         if (ndr_flags & NDR_SCALARS) {
9622                 NDR_CHECK(ndr_pull_align(ndr, 5));
9623                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9624                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9625                 if (_ptr_object_dn) {
9626                         NDR_PULL_ALLOC(ndr, r->object_dn);
9627                 } else {
9628                         r->object_dn = NULL;
9629                 }
9630                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9631                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9632         }
9633         if (ndr_flags & NDR_BUFFERS) {
9634                 if (r->object_dn) {
9635                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9636                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9637                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9638                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9639                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9640                                 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));
9641                         }
9642                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9643                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9644                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9645                 }
9646         }
9647         return NDR_ERR_SUCCESS;
9648 }
9649
9650 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9651 {
9652         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest1");
9653         ndr->depth++;
9654         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9655         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9656         ndr->depth++;
9657         if (r->object_dn) {
9658                 ndr_print_string(ndr, "object_dn", r->object_dn);
9659         }
9660         ndr->depth--;
9661         ndr_print_GUID(ndr, "guid1", &r->guid1);
9662         ndr->depth--;
9663 }
9664
9665 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9666 {
9667         if (ndr_flags & NDR_SCALARS) {
9668                 NDR_CHECK(ndr_push_align(ndr, 5));
9669                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9670                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9671                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
9673                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string1));
9674                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string2));
9675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
9676                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9677         }
9678         if (ndr_flags & NDR_BUFFERS) {
9679                 if (r->object_dn) {
9680                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9681                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9682                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9683                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9684                 }
9685                 if (r->string1) {
9686                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9687                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9688                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9689                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string1, ndr_charset_length(r->string1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9690                 }
9691                 if (r->string2) {
9692                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9693                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9695                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string2, ndr_charset_length(r->string2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9696                 }
9697         }
9698         return NDR_ERR_SUCCESS;
9699 }
9700
9701 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
9702 {
9703         uint32_t _ptr_object_dn;
9704         TALLOC_CTX *_mem_save_object_dn_0;
9705         uint32_t _ptr_string1;
9706         TALLOC_CTX *_mem_save_string1_0;
9707         uint32_t _ptr_string2;
9708         TALLOC_CTX *_mem_save_string2_0;
9709         if (ndr_flags & NDR_SCALARS) {
9710                 NDR_CHECK(ndr_pull_align(ndr, 5));
9711                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9712                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9713                 if (_ptr_object_dn) {
9714                         NDR_PULL_ALLOC(ndr, r->object_dn);
9715                 } else {
9716                         r->object_dn = NULL;
9717                 }
9718                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
9720                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string1));
9721                 if (_ptr_string1) {
9722                         NDR_PULL_ALLOC(ndr, r->string1);
9723                 } else {
9724                         r->string1 = NULL;
9725                 }
9726                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string2));
9727                 if (_ptr_string2) {
9728                         NDR_PULL_ALLOC(ndr, r->string2);
9729                 } else {
9730                         r->string2 = NULL;
9731                 }
9732                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
9733                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9734         }
9735         if (ndr_flags & NDR_BUFFERS) {
9736                 if (r->object_dn) {
9737                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9738                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9739                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9740                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9741                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9742                                 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));
9743                         }
9744                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9745                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9746                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9747                 }
9748                 if (r->string1) {
9749                         _mem_save_string1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9750                         NDR_PULL_SET_MEM_CTX(ndr, r->string1, 0);
9751                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string1));
9752                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string1));
9753                         if (ndr_get_array_length(ndr, &r->string1) > ndr_get_array_size(ndr, &r->string1)) {
9754                                 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));
9755                         }
9756                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t)));
9757                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string1, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t), CH_UTF16));
9758                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string1_0, 0);
9759                 }
9760                 if (r->string2) {
9761                         _mem_save_string2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9762                         NDR_PULL_SET_MEM_CTX(ndr, r->string2, 0);
9763                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string2));
9764                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string2));
9765                         if (ndr_get_array_length(ndr, &r->string2) > ndr_get_array_size(ndr, &r->string2)) {
9766                                 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));
9767                         }
9768                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t)));
9769                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string2, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t), CH_UTF16));
9770                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string2_0, 0);
9771                 }
9772         }
9773         return NDR_ERR_SUCCESS;
9774 }
9775
9776 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9777 {
9778         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest2");
9779         ndr->depth++;
9780         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9781         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9782         ndr->depth++;
9783         if (r->object_dn) {
9784                 ndr_print_string(ndr, "object_dn", r->object_dn);
9785         }
9786         ndr->depth--;
9787         ndr_print_GUID(ndr, "guid1", &r->guid1);
9788         ndr_print_uint32(ndr, "flags", r->flags);
9789         ndr_print_ptr(ndr, "string1", r->string1);
9790         ndr->depth++;
9791         if (r->string1) {
9792                 ndr_print_string(ndr, "string1", r->string1);
9793         }
9794         ndr->depth--;
9795         ndr_print_ptr(ndr, "string2", r->string2);
9796         ndr->depth++;
9797         if (r->string2) {
9798                 ndr_print_string(ndr, "string2", r->string2);
9799         }
9800         ndr->depth--;
9801         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
9802         ndr->depth--;
9803 }
9804
9805 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaGetInfoRequest *r)
9806 {
9807         if (ndr_flags & NDR_SCALARS) {
9808                 int level = ndr_push_get_switch_value(ndr, r);
9809                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
9810                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9811                 switch (level) {
9812                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9813                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9814                         break; }
9815
9816                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9817                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9818                         break; }
9819
9820                         default:
9821                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9822                 }
9823         }
9824         if (ndr_flags & NDR_BUFFERS) {
9825                 int level = ndr_push_get_switch_value(ndr, r);
9826                 switch (level) {
9827                         case DRSUAPI_DS_REPLICA_GET_INFO:
9828                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9829                         break;
9830
9831                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9832                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9833                         break;
9834
9835                         default:
9836                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9837                 }
9838         }
9839         return NDR_ERR_SUCCESS;
9840 }
9841
9842 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaGetInfoRequest *r)
9843 {
9844         int level;
9845         uint32_t _level;
9846         level = ndr_pull_get_switch_value(ndr, r);
9847         if (ndr_flags & NDR_SCALARS) {
9848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9849                 if (_level != level) {
9850                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9851                 }
9852                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9853                 switch (level) {
9854                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9855                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9856                         break; }
9857
9858                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9859                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9860                         break; }
9861
9862                         default:
9863                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9864                 }
9865         }
9866         if (ndr_flags & NDR_BUFFERS) {
9867                 switch (level) {
9868                         case DRSUAPI_DS_REPLICA_GET_INFO:
9869                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9870                         break;
9871
9872                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9873                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9874                         break;
9875
9876                         default:
9877                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9878                 }
9879         }
9880         return NDR_ERR_SUCCESS;
9881 }
9882
9883 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaGetInfoRequest *r)
9884 {
9885         int level;
9886         level = ndr_print_get_switch_value(ndr, r);
9887         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaGetInfoRequest");
9888         switch (level) {
9889                 case DRSUAPI_DS_REPLICA_GET_INFO:
9890                         ndr_print_drsuapi_DsReplicaGetInfoRequest1(ndr, "req1", &r->req1);
9891                 break;
9892
9893                 case DRSUAPI_DS_REPLICA_GET_INFO2:
9894                         ndr_print_drsuapi_DsReplicaGetInfoRequest2(ndr, "req2", &r->req2);
9895                 break;
9896
9897                 default:
9898                         ndr_print_bad_level(ndr, name, level);
9899         }
9900 }
9901
9902 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbour *r)
9903 {
9904         if (ndr_flags & NDR_SCALARS) {
9905                 NDR_CHECK(ndr_push_align(ndr, 8));
9906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context_dn));
9907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
9908                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
9909                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_obj_dn));
9910                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
9911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9912                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9913                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9914                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9915                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9916                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
9917                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
9918                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_success));
9919                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
9920                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
9921                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
9922                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9923         }
9924         if (ndr_flags & NDR_BUFFERS) {
9925                 if (r->naming_context_dn) {
9926                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9927                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9928                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9929                         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));
9930                 }
9931                 if (r->source_dsa_obj_dn) {
9932                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9933                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9934                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9935                         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));
9936                 }
9937                 if (r->source_dsa_address) {
9938                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9939                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9940                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9941                         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));
9942                 }
9943                 if (r->transport_obj_dn) {
9944                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9945                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9946                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9947                         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));
9948                 }
9949         }
9950         return NDR_ERR_SUCCESS;
9951 }
9952
9953 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
9954 {
9955         uint32_t _ptr_naming_context_dn;
9956         TALLOC_CTX *_mem_save_naming_context_dn_0;
9957         uint32_t _ptr_source_dsa_obj_dn;
9958         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
9959         uint32_t _ptr_source_dsa_address;
9960         TALLOC_CTX *_mem_save_source_dsa_address_0;
9961         uint32_t _ptr_transport_obj_dn;
9962         TALLOC_CTX *_mem_save_transport_obj_dn_0;
9963         if (ndr_flags & NDR_SCALARS) {
9964                 NDR_CHECK(ndr_pull_align(ndr, 8));
9965                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context_dn));
9966                 if (_ptr_naming_context_dn) {
9967                         NDR_PULL_ALLOC(ndr, r->naming_context_dn);
9968                 } else {
9969                         r->naming_context_dn = NULL;
9970                 }
9971                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
9972                 if (_ptr_source_dsa_obj_dn) {
9973                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
9974                 } else {
9975                         r->source_dsa_obj_dn = NULL;
9976                 }
9977                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
9978                 if (_ptr_source_dsa_address) {
9979                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
9980                 } else {
9981                         r->source_dsa_address = NULL;
9982                 }
9983                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_obj_dn));
9984                 if (_ptr_transport_obj_dn) {
9985                         NDR_PULL_ALLOC(ndr, r->transport_obj_dn);
9986                 } else {
9987                         r->transport_obj_dn = NULL;
9988                 }
9989                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
9990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9991                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9992                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9993                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9994                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9995                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
9996                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
9997                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_success));
9998                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
9999                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
10000                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
10001                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10002         }
10003         if (ndr_flags & NDR_BUFFERS) {
10004                 if (r->naming_context_dn) {
10005                         _mem_save_naming_context_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10006                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
10007                         NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
10008                         NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
10009                         if (ndr_get_array_length(ndr, &r->naming_context_dn) > ndr_get_array_size(ndr, &r->naming_context_dn)) {
10010                                 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));
10011                         }
10012                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t)));
10013                         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));
10014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
10015                 }
10016                 if (r->source_dsa_obj_dn) {
10017                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10018                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
10019                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
10020                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
10021                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
10022                                 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));
10023                         }
10024                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
10025                         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));
10026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
10027                 }
10028                 if (r->source_dsa_address) {
10029                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10030                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
10031                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
10032                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
10033                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
10034                                 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));
10035                         }
10036                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
10037                         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));
10038                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
10039                 }
10040                 if (r->transport_obj_dn) {
10041                         _mem_save_transport_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10042                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
10043                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
10044                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
10045                         if (ndr_get_array_length(ndr, &r->transport_obj_dn) > ndr_get_array_size(ndr, &r->transport_obj_dn)) {
10046                                 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));
10047                         }
10048                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t)));
10049                         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));
10050                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
10051                 }
10052         }
10053         return NDR_ERR_SUCCESS;
10054 }
10055
10056 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbour(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbour *r)
10057 {
10058         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbour");
10059         ndr->depth++;
10060         ndr_print_ptr(ndr, "naming_context_dn", r->naming_context_dn);
10061         ndr->depth++;
10062         if (r->naming_context_dn) {
10063                 ndr_print_string(ndr, "naming_context_dn", r->naming_context_dn);
10064         }
10065         ndr->depth--;
10066         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10067         ndr->depth++;
10068         if (r->source_dsa_obj_dn) {
10069                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10070         }
10071         ndr->depth--;
10072         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
10073         ndr->depth++;
10074         if (r->source_dsa_address) {
10075                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
10076         }
10077         ndr->depth--;
10078         ndr_print_ptr(ndr, "transport_obj_dn", r->transport_obj_dn);
10079         ndr->depth++;
10080         if (r->transport_obj_dn) {
10081                 ndr_print_string(ndr, "transport_obj_dn", r->transport_obj_dn);
10082         }
10083         ndr->depth--;
10084         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
10085         ndr_print_uint32(ndr, "reserved", r->reserved);
10086         ndr_print_GUID(ndr, "naming_context_obj_guid", &r->naming_context_obj_guid);
10087         ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
10088         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
10089         ndr_print_GUID(ndr, "transport_obj_guid", &r->transport_obj_guid);
10090         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
10091         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
10092         ndr_print_NTTIME(ndr, "last_success", r->last_success);
10093         ndr_print_NTTIME(ndr, "last_attempt", r->last_attempt);
10094         ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
10095         ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
10096         ndr->depth--;
10097 }
10098
10099 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbourCtr *r)
10100 {
10101         uint32_t cntr_array_0;
10102         if (ndr_flags & NDR_SCALARS) {
10103                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10104                 NDR_CHECK(ndr_push_align(ndr, 8));
10105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10107                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10108                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10109                 }
10110                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10111         }
10112         if (ndr_flags & NDR_BUFFERS) {
10113                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10114                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10115                 }
10116         }
10117         return NDR_ERR_SUCCESS;
10118 }
10119
10120 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
10121 {
10122         uint32_t cntr_array_0;
10123         TALLOC_CTX *_mem_save_array_0;
10124         if (ndr_flags & NDR_SCALARS) {
10125                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10126                 NDR_CHECK(ndr_pull_align(ndr, 8));
10127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10128                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10129                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10130                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10131                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10132                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10133                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10134                 }
10135                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10136                 if (r->array) {
10137                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10138                 }
10139                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10140         }
10141         if (ndr_flags & NDR_BUFFERS) {
10142                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10143                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10144                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10145                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10146                 }
10147                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10148         }
10149         return NDR_ERR_SUCCESS;
10150 }
10151
10152 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbourCtr *r)
10153 {
10154         uint32_t cntr_array_0;
10155         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbourCtr");
10156         ndr->depth++;
10157         ndr_print_uint32(ndr, "count", r->count);
10158         ndr_print_uint32(ndr, "reserved", r->reserved);
10159         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10160         ndr->depth++;
10161         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10162                 char *idx_0=NULL;
10163                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10164                         ndr_print_drsuapi_DsReplicaNeighbour(ndr, "array", &r->array[cntr_array_0]);
10165                         free(idx_0);
10166                 }
10167         }
10168         ndr->depth--;
10169         ndr->depth--;
10170 }
10171
10172 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtr *r)
10173 {
10174         uint32_t cntr_array_0;
10175         if (ndr_flags & NDR_SCALARS) {
10176                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10177                 NDR_CHECK(ndr_push_align(ndr, 8));
10178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10180                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10181                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10182                 }
10183                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10184         }
10185         if (ndr_flags & NDR_BUFFERS) {
10186         }
10187         return NDR_ERR_SUCCESS;
10188 }
10189
10190 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
10191 {
10192         uint32_t cntr_array_0;
10193         TALLOC_CTX *_mem_save_array_0;
10194         if (ndr_flags & NDR_SCALARS) {
10195                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10196                 NDR_CHECK(ndr_pull_align(ndr, 8));
10197                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10198                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10199                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10200                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10201                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10202                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10203                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10204                 }
10205                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10206                 if (r->array) {
10207                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10208                 }
10209                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10210         }
10211         if (ndr_flags & NDR_BUFFERS) {
10212         }
10213         return NDR_ERR_SUCCESS;
10214 }
10215
10216 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtr *r)
10217 {
10218         uint32_t cntr_array_0;
10219         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtr");
10220         ndr->depth++;
10221         ndr_print_uint32(ndr, "count", r->count);
10222         ndr_print_uint32(ndr, "reserved", r->reserved);
10223         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10224         ndr->depth++;
10225         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10226                 char *idx_0=NULL;
10227                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10228                         ndr_print_drsuapi_DsReplicaCursor(ndr, "array", &r->array[cntr_array_0]);
10229                         free(idx_0);
10230                 }
10231         }
10232         ndr->depth--;
10233         ndr->depth--;
10234 }
10235
10236 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData *r)
10237 {
10238         if (ndr_flags & NDR_SCALARS) {
10239                 NDR_CHECK(ndr_push_align(ndr, 8));
10240                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10242                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10243                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10244                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10245                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10246                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10247         }
10248         if (ndr_flags & NDR_BUFFERS) {
10249                 if (r->attribute_name) {
10250                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10251                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10252                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10253                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10254                 }
10255         }
10256         return NDR_ERR_SUCCESS;
10257 }
10258
10259 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
10260 {
10261         uint32_t _ptr_attribute_name;
10262         TALLOC_CTX *_mem_save_attribute_name_0;
10263         if (ndr_flags & NDR_SCALARS) {
10264                 NDR_CHECK(ndr_pull_align(ndr, 8));
10265                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10266                 if (_ptr_attribute_name) {
10267                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10268                 } else {
10269                         r->attribute_name = NULL;
10270                 }
10271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10272                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10273                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10274                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10275                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10276                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10277         }
10278         if (ndr_flags & NDR_BUFFERS) {
10279                 if (r->attribute_name) {
10280                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10281                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10282                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10283                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10284                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10285                                 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));
10286                         }
10287                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10288                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10289                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10290                 }
10291         }
10292         return NDR_ERR_SUCCESS;
10293 }
10294
10295 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData *r)
10296 {
10297         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData");
10298         ndr->depth++;
10299         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10300         ndr->depth++;
10301         if (r->attribute_name) {
10302                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10303         }
10304         ndr->depth--;
10305         ndr_print_uint32(ndr, "version", r->version);
10306         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10307         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10308         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10309         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10310         ndr->depth--;
10311 }
10312
10313 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10314 {
10315         uint32_t cntr_array_0;
10316         if (ndr_flags & NDR_SCALARS) {
10317                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10318                 NDR_CHECK(ndr_push_align(ndr, 8));
10319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10321                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10322                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10323                 }
10324                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10325         }
10326         if (ndr_flags & NDR_BUFFERS) {
10327                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10328                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10329                 }
10330         }
10331         return NDR_ERR_SUCCESS;
10332 }
10333
10334 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
10335 {
10336         uint32_t cntr_array_0;
10337         TALLOC_CTX *_mem_save_array_0;
10338         if (ndr_flags & NDR_SCALARS) {
10339                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10340                 NDR_CHECK(ndr_pull_align(ndr, 8));
10341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10343                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10344                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10345                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10346                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10347                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10348                 }
10349                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10350                 if (r->array) {
10351                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10352                 }
10353                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10354         }
10355         if (ndr_flags & NDR_BUFFERS) {
10356                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10357                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10358                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10359                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10360                 }
10361                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10362         }
10363         return NDR_ERR_SUCCESS;
10364 }
10365
10366 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10367 {
10368         uint32_t cntr_array_0;
10369         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaDataCtr");
10370         ndr->depth++;
10371         ndr_print_uint32(ndr, "count", r->count);
10372         ndr_print_uint32(ndr, "reserved", r->reserved);
10373         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10374         ndr->depth++;
10375         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10376                 char *idx_0=NULL;
10377                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10378                         ndr_print_drsuapi_DsReplicaObjMetaData(ndr, "array", &r->array[cntr_array_0]);
10379                         free(idx_0);
10380                 }
10381         }
10382         ndr->depth--;
10383         ndr->depth--;
10384 }
10385
10386 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
10387 {
10388         if (ndr_flags & NDR_SCALARS) {
10389                 NDR_CHECK(ndr_push_align(ndr, 5));
10390                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
10391                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10392                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
10393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
10394                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
10395                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10396         }
10397         if (ndr_flags & NDR_BUFFERS) {
10398                 if (r->dsa_obj_dn) {
10399                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10400                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10401                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10402                         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));
10403                 }
10404         }
10405         return NDR_ERR_SUCCESS;
10406 }
10407
10408 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
10409 {
10410         uint32_t _ptr_dsa_obj_dn;
10411         TALLOC_CTX *_mem_save_dsa_obj_dn_0;
10412         if (ndr_flags & NDR_SCALARS) {
10413                 NDR_CHECK(ndr_pull_align(ndr, 5));
10414                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
10415                 if (_ptr_dsa_obj_dn) {
10416                         NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
10417                 } else {
10418                         r->dsa_obj_dn = NULL;
10419                 }
10420                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10421                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
10422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
10423                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
10424                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10425         }
10426         if (ndr_flags & NDR_BUFFERS) {
10427                 if (r->dsa_obj_dn) {
10428                         _mem_save_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10429                         NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
10430                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
10431                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
10432                         if (ndr_get_array_length(ndr, &r->dsa_obj_dn) > ndr_get_array_size(ndr, &r->dsa_obj_dn)) {
10433                                 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));
10434                         }
10435                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t)));
10436                         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));
10437                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
10438                 }
10439         }
10440         return NDR_ERR_SUCCESS;
10441 }
10442
10443 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailure(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailure *r)
10444 {
10445         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailure");
10446         ndr->depth++;
10447         ndr_print_ptr(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10448         ndr->depth++;
10449         if (r->dsa_obj_dn) {
10450                 ndr_print_string(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10451         }
10452         ndr->depth--;
10453         ndr_print_GUID(ndr, "dsa_obj_guid", &r->dsa_obj_guid);
10454         ndr_print_NTTIME(ndr, "first_failure", r->first_failure);
10455         ndr_print_uint32(ndr, "num_failures", r->num_failures);
10456         ndr_print_WERROR(ndr, "last_result", r->last_result);
10457         ndr->depth--;
10458 }
10459
10460 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10461 {
10462         uint32_t cntr_array_0;
10463         if (ndr_flags & NDR_SCALARS) {
10464                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10465                 NDR_CHECK(ndr_push_align(ndr, 5));
10466                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10468                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10469                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10470                 }
10471                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10472         }
10473         if (ndr_flags & NDR_BUFFERS) {
10474                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10475                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10476                 }
10477         }
10478         return NDR_ERR_SUCCESS;
10479 }
10480
10481 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10482 {
10483         uint32_t cntr_array_0;
10484         TALLOC_CTX *_mem_save_array_0;
10485         if (ndr_flags & NDR_SCALARS) {
10486                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10487                 NDR_CHECK(ndr_pull_align(ndr, 5));
10488                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10489                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10490                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10491                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10492                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10493                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10494                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10495                 }
10496                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10497                 if (r->array) {
10498                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10499                 }
10500                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10501         }
10502         if (ndr_flags & NDR_BUFFERS) {
10503                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10504                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10505                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10506                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10507                 }
10508                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10509         }
10510         return NDR_ERR_SUCCESS;
10511 }
10512
10513 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10514 {
10515         uint32_t cntr_array_0;
10516         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailuresCtr");
10517         ndr->depth++;
10518         ndr_print_uint32(ndr, "count", r->count);
10519         ndr_print_uint32(ndr, "reserved", r->reserved);
10520         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10521         ndr->depth++;
10522         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10523                 char *idx_0=NULL;
10524                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10525                         ndr_print_drsuapi_DsReplicaKccDsaFailure(ndr, "array", &r->array[cntr_array_0]);
10526                         free(idx_0);
10527                 }
10528         }
10529         ndr->depth--;
10530         ndr->depth--;
10531 }
10532
10533 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
10534 {
10535         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
10536         return NDR_ERR_SUCCESS;
10537 }
10538
10539 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
10540 {
10541         uint16_t v;
10542         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
10543         *r = v;
10544         return NDR_ERR_SUCCESS;
10545 }
10546
10547 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaOpType r)
10548 {
10549         const char *val = NULL;
10550
10551         switch (r) {
10552                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: val = "DRSUAPI_DS_REPLICA_OP_TYPE_SYNC"; break;
10553                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: val = "DRSUAPI_DS_REPLICA_OP_TYPE_ADD"; break;
10554                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: val = "DRSUAPI_DS_REPLICA_OP_TYPE_DELETE"; break;
10555                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: val = "DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY"; break;
10556                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: val = "DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS"; break;
10557         }
10558         ndr_print_enum(ndr, name, "ENUM", val, r);
10559 }
10560
10561 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
10562 {
10563         if (ndr_flags & NDR_SCALARS) {
10564                 NDR_CHECK(ndr_push_align(ndr, 5));
10565                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
10566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
10567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
10568                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
10569                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
10570                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
10571                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
10572                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
10573                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10574                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10575                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10576         }
10577         if (ndr_flags & NDR_BUFFERS) {
10578                 if (r->nc_dn) {
10579                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10580                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10581                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10582                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10583                 }
10584                 if (r->remote_dsa_obj_dn) {
10585                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10586                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10587                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10588                         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));
10589                 }
10590                 if (r->remote_dsa_address) {
10591                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10592                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10593                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10594                         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));
10595                 }
10596         }
10597         return NDR_ERR_SUCCESS;
10598 }
10599
10600 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
10601 {
10602         uint32_t _ptr_nc_dn;
10603         TALLOC_CTX *_mem_save_nc_dn_0;
10604         uint32_t _ptr_remote_dsa_obj_dn;
10605         TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
10606         uint32_t _ptr_remote_dsa_address;
10607         TALLOC_CTX *_mem_save_remote_dsa_address_0;
10608         if (ndr_flags & NDR_SCALARS) {
10609                 NDR_CHECK(ndr_pull_align(ndr, 5));
10610                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
10611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
10612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
10613                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
10614                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
10615                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
10616                 if (_ptr_nc_dn) {
10617                         NDR_PULL_ALLOC(ndr, r->nc_dn);
10618                 } else {
10619                         r->nc_dn = NULL;
10620                 }
10621                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_obj_dn));
10622                 if (_ptr_remote_dsa_obj_dn) {
10623                         NDR_PULL_ALLOC(ndr, r->remote_dsa_obj_dn);
10624                 } else {
10625                         r->remote_dsa_obj_dn = NULL;
10626                 }
10627                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_address));
10628                 if (_ptr_remote_dsa_address) {
10629                         NDR_PULL_ALLOC(ndr, r->remote_dsa_address);
10630                 } else {
10631                         r->remote_dsa_address = NULL;
10632                 }
10633                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10634                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10635                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10636         }
10637         if (ndr_flags & NDR_BUFFERS) {
10638                 if (r->nc_dn) {
10639                         _mem_save_nc_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10640                         NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
10641                         NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
10642                         NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
10643                         if (ndr_get_array_length(ndr, &r->nc_dn) > ndr_get_array_size(ndr, &r->nc_dn)) {
10644                                 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));
10645                         }
10646                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t)));
10647                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t), CH_UTF16));
10648                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
10649                 }
10650                 if (r->remote_dsa_obj_dn) {
10651                         _mem_save_remote_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10652                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
10653                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
10654                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
10655                         if (ndr_get_array_length(ndr, &r->remote_dsa_obj_dn) > ndr_get_array_size(ndr, &r->remote_dsa_obj_dn)) {
10656                                 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));
10657                         }
10658                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t)));
10659                         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));
10660                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
10661                 }
10662                 if (r->remote_dsa_address) {
10663                         _mem_save_remote_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10664                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
10665                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
10666                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
10667                         if (ndr_get_array_length(ndr, &r->remote_dsa_address) > ndr_get_array_size(ndr, &r->remote_dsa_address)) {
10668                                 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));
10669                         }
10670                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t)));
10671                         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));
10672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
10673                 }
10674         }
10675         return NDR_ERR_SUCCESS;
10676 }
10677
10678 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOp *r)
10679 {
10680         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOp");
10681         ndr->depth++;
10682         ndr_print_NTTIME(ndr, "operation_start", r->operation_start);
10683         ndr_print_uint32(ndr, "serial_num", r->serial_num);
10684         ndr_print_uint32(ndr, "priority", r->priority);
10685         ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
10686         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
10687         ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
10688         ndr->depth++;
10689         if (r->nc_dn) {
10690                 ndr_print_string(ndr, "nc_dn", r->nc_dn);
10691         }
10692         ndr->depth--;
10693         ndr_print_ptr(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10694         ndr->depth++;
10695         if (r->remote_dsa_obj_dn) {
10696                 ndr_print_string(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10697         }
10698         ndr->depth--;
10699         ndr_print_ptr(ndr, "remote_dsa_address", r->remote_dsa_address);
10700         ndr->depth++;
10701         if (r->remote_dsa_address) {
10702                 ndr_print_string(ndr, "remote_dsa_address", r->remote_dsa_address);
10703         }
10704         ndr->depth--;
10705         ndr_print_GUID(ndr, "nc_obj_guid", &r->nc_obj_guid);
10706         ndr_print_GUID(ndr, "remote_dsa_obj_guid", &r->remote_dsa_obj_guid);
10707         ndr->depth--;
10708 }
10709
10710 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOpCtr *r)
10711 {
10712         uint32_t cntr_array_0;
10713         if (ndr_flags & NDR_SCALARS) {
10714                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10715                 NDR_CHECK(ndr_push_align(ndr, 5));
10716                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
10717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10718                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10719                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10720                 }
10721                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10722         }
10723         if (ndr_flags & NDR_BUFFERS) {
10724                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10725                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10726                 }
10727         }
10728         return NDR_ERR_SUCCESS;
10729 }
10730
10731 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
10732 {
10733         uint32_t cntr_array_0;
10734         TALLOC_CTX *_mem_save_array_0;
10735         if (ndr_flags & NDR_SCALARS) {
10736                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10737                 NDR_CHECK(ndr_pull_align(ndr, 5));
10738                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
10739                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10740                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10741                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10742                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10743                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10744                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10745                 }
10746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10747                 if (r->array) {
10748                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10749                 }
10750                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10751         }
10752         if (ndr_flags & NDR_BUFFERS) {
10753                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10754                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10755                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10756                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10757                 }
10758                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10759         }
10760         return NDR_ERR_SUCCESS;
10761 }
10762
10763 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOpCtr *r)
10764 {
10765         uint32_t cntr_array_0;
10766         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOpCtr");
10767         ndr->depth++;
10768         ndr_print_NTTIME(ndr, "time", r->time);
10769         ndr_print_uint32(ndr, "count", r->count);
10770         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10771         ndr->depth++;
10772         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10773                 char *idx_0=NULL;
10774                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10775                         ndr_print_drsuapi_DsReplicaOp(ndr, "array", &r->array[cntr_array_0]);
10776                         free(idx_0);
10777                 }
10778         }
10779         ndr->depth--;
10780         ndr->depth--;
10781 }
10782
10783 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData *r)
10784 {
10785         if (ndr_flags & NDR_SCALARS) {
10786                 NDR_CHECK(ndr_push_align(ndr, 8));
10787                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
10789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
10790                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
10791                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
10792                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
10793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10794                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10795                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10796                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10797                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10798                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10799         }
10800         if (ndr_flags & NDR_BUFFERS) {
10801                 if (r->attribute_name) {
10802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10803                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10805                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10806                 }
10807                 if (r->object_dn) {
10808                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10809                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10810                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10811                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10812                 }
10813                 if (r->binary) {
10814                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
10815                 }
10816         }
10817         return NDR_ERR_SUCCESS;
10818 }
10819
10820 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
10821 {
10822         uint32_t _ptr_attribute_name;
10823         TALLOC_CTX *_mem_save_attribute_name_0;
10824         uint32_t _ptr_object_dn;
10825         TALLOC_CTX *_mem_save_object_dn_0;
10826         uint32_t _ptr_binary;
10827         TALLOC_CTX *_mem_save_binary_0;
10828         if (ndr_flags & NDR_SCALARS) {
10829                 NDR_CHECK(ndr_pull_align(ndr, 8));
10830                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10831                 if (_ptr_attribute_name) {
10832                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10833                 } else {
10834                         r->attribute_name = NULL;
10835                 }
10836                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
10837                 if (_ptr_object_dn) {
10838                         NDR_PULL_ALLOC(ndr, r->object_dn);
10839                 } else {
10840                         r->object_dn = NULL;
10841                 }
10842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
10843                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
10844                 if (_ptr_binary) {
10845                         NDR_PULL_ALLOC(ndr, r->binary);
10846                 } else {
10847                         r->binary = NULL;
10848                 }
10849                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
10850                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
10851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10852                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10853                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10854                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10855                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10856                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10857         }
10858         if (ndr_flags & NDR_BUFFERS) {
10859                 if (r->attribute_name) {
10860                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10861                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10862                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10863                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10864                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10865                                 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));
10866                         }
10867                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10868                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10869                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10870                 }
10871                 if (r->object_dn) {
10872                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10873                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
10874                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
10875                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
10876                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
10877                                 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));
10878                         }
10879                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
10880                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
10881                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
10882                 }
10883                 if (r->binary) {
10884                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
10885                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
10886                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
10887                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
10888                 }
10889         }
10890         return NDR_ERR_SUCCESS;
10891 }
10892
10893 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData *r)
10894 {
10895         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData");
10896         ndr->depth++;
10897         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10898         ndr->depth++;
10899         if (r->attribute_name) {
10900                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10901         }
10902         ndr->depth--;
10903         ndr_print_ptr(ndr, "object_dn", r->object_dn);
10904         ndr->depth++;
10905         if (r->object_dn) {
10906                 ndr_print_string(ndr, "object_dn", r->object_dn);
10907         }
10908         ndr->depth--;
10909         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);
10910         ndr_print_ptr(ndr, "binary", r->binary);
10911         ndr->depth++;
10912         if (r->binary) {
10913                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
10914         }
10915         ndr->depth--;
10916         ndr_print_NTTIME(ndr, "deleted", r->deleted);
10917         ndr_print_NTTIME(ndr, "created", r->created);
10918         ndr_print_uint32(ndr, "version", r->version);
10919         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10920         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10921         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10922         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10923         ndr->depth--;
10924 }
10925
10926 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10927 {
10928         uint32_t cntr_array_0;
10929         if (ndr_flags & NDR_SCALARS) {
10930                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10931                 NDR_CHECK(ndr_push_align(ndr, 8));
10932                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
10934                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10935                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10936                 }
10937                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10938         }
10939         if (ndr_flags & NDR_BUFFERS) {
10940                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10941                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10942                 }
10943         }
10944         return NDR_ERR_SUCCESS;
10945 }
10946
10947 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10948 {
10949         uint32_t cntr_array_0;
10950         TALLOC_CTX *_mem_save_array_0;
10951         if (ndr_flags & NDR_SCALARS) {
10952                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10953                 NDR_CHECK(ndr_pull_align(ndr, 8));
10954                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10955                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
10956                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10957                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10958                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10959                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10960                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10961                 }
10962                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10963                 if (r->array) {
10964                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10965                 }
10966                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10967         }
10968         if (ndr_flags & NDR_BUFFERS) {
10969                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10970                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10971                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10972                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10973                 }
10974                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10975         }
10976         return NDR_ERR_SUCCESS;
10977 }
10978
10979 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10980 {
10981         uint32_t cntr_array_0;
10982         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaDataCtr");
10983         ndr->depth++;
10984         ndr_print_uint32(ndr, "count", r->count);
10985         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
10986         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10987         ndr->depth++;
10988         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10989                 char *idx_0=NULL;
10990                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10991                         ndr_print_drsuapi_DsReplicaAttrValMetaData(ndr, "array", &r->array[cntr_array_0]);
10992                         free(idx_0);
10993                 }
10994         }
10995         ndr->depth--;
10996         ndr->depth--;
10997 }
10998
10999 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2Ctr *r)
11000 {
11001         uint32_t cntr_array_0;
11002         if (ndr_flags & NDR_SCALARS) {
11003                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11004                 NDR_CHECK(ndr_push_align(ndr, 8));
11005                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11007                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11008                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11009                 }
11010                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11011         }
11012         if (ndr_flags & NDR_BUFFERS) {
11013         }
11014         return NDR_ERR_SUCCESS;
11015 }
11016
11017 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
11018 {
11019         uint32_t cntr_array_0;
11020         TALLOC_CTX *_mem_save_array_0;
11021         if (ndr_flags & NDR_SCALARS) {
11022                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11023                 NDR_CHECK(ndr_pull_align(ndr, 8));
11024                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11026                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11027                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11028                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11029                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11030                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11031                 }
11032                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11033                 if (r->array) {
11034                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11035                 }
11036                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11037         }
11038         if (ndr_flags & NDR_BUFFERS) {
11039         }
11040         return NDR_ERR_SUCCESS;
11041 }
11042
11043 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2Ctr *r)
11044 {
11045         uint32_t cntr_array_0;
11046         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2Ctr");
11047         ndr->depth++;
11048         ndr_print_uint32(ndr, "count", r->count);
11049         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11050         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11051         ndr->depth++;
11052         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11053                 char *idx_0=NULL;
11054                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11055                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "array", &r->array[cntr_array_0]);
11056                         free(idx_0);
11057                 }
11058         }
11059         ndr->depth--;
11060         ndr->depth--;
11061 }
11062
11063 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3 *r)
11064 {
11065         if (ndr_flags & NDR_SCALARS) {
11066                 NDR_CHECK(ndr_push_align(ndr, 8));
11067                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11068                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
11069                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
11070                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
11071                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11072         }
11073         if (ndr_flags & NDR_BUFFERS) {
11074                 if (r->source_dsa_obj_dn) {
11075                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11076                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11077                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11078                         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));
11079                 }
11080         }
11081         return NDR_ERR_SUCCESS;
11082 }
11083
11084 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
11085 {
11086         uint32_t _ptr_source_dsa_obj_dn;
11087         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
11088         if (ndr_flags & NDR_SCALARS) {
11089                 NDR_CHECK(ndr_pull_align(ndr, 8));
11090                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11091                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
11092                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
11093                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
11094                 if (_ptr_source_dsa_obj_dn) {
11095                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
11096                 } else {
11097                         r->source_dsa_obj_dn = NULL;
11098                 }
11099                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11100         }
11101         if (ndr_flags & NDR_BUFFERS) {
11102                 if (r->source_dsa_obj_dn) {
11103                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11104                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
11105                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
11106                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
11107                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
11108                                 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));
11109                         }
11110                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
11111                         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));
11112                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
11113                 }
11114         }
11115         return NDR_ERR_SUCCESS;
11116 }
11117
11118 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3 *r)
11119 {
11120         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3");
11121         ndr->depth++;
11122         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
11123         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
11124         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
11125         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11126         ndr->depth++;
11127         if (r->source_dsa_obj_dn) {
11128                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11129         }
11130         ndr->depth--;
11131         ndr->depth--;
11132 }
11133
11134 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3Ctr *r)
11135 {
11136         uint32_t cntr_array_0;
11137         if (ndr_flags & NDR_SCALARS) {
11138                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11139                 NDR_CHECK(ndr_push_align(ndr, 8));
11140                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11142                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11143                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11144                 }
11145                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11146         }
11147         if (ndr_flags & NDR_BUFFERS) {
11148                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11149                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11150                 }
11151         }
11152         return NDR_ERR_SUCCESS;
11153 }
11154
11155 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
11156 {
11157         uint32_t cntr_array_0;
11158         TALLOC_CTX *_mem_save_array_0;
11159         if (ndr_flags & NDR_SCALARS) {
11160                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11161                 NDR_CHECK(ndr_pull_align(ndr, 8));
11162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11164                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11165                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11166                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11167                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11168                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11169                 }
11170                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11171                 if (r->array) {
11172                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11173                 }
11174                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11175         }
11176         if (ndr_flags & NDR_BUFFERS) {
11177                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11178                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11179                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11180                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11181                 }
11182                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11183         }
11184         return NDR_ERR_SUCCESS;
11185 }
11186
11187 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3Ctr *r)
11188 {
11189         uint32_t cntr_array_0;
11190         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3Ctr");
11191         ndr->depth++;
11192         ndr_print_uint32(ndr, "count", r->count);
11193         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11194         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11195         ndr->depth++;
11196         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11197                 char *idx_0=NULL;
11198                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11199                         ndr_print_drsuapi_DsReplicaCursor3(ndr, "array", &r->array[cntr_array_0]);
11200                         free(idx_0);
11201                 }
11202         }
11203         ndr->depth--;
11204         ndr->depth--;
11205 }
11206
11207 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2 *r)
11208 {
11209         if (ndr_flags & NDR_SCALARS) {
11210                 NDR_CHECK(ndr_push_align(ndr, 8));
11211                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11213                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11214                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11215                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11216                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11217                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11218                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11219         }
11220         if (ndr_flags & NDR_BUFFERS) {
11221                 if (r->attribute_name) {
11222                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11223                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11224                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11225                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11226                 }
11227                 if (r->originating_dsa_dn) {
11228                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11229                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11230                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11231                         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));
11232                 }
11233         }
11234         return NDR_ERR_SUCCESS;
11235 }
11236
11237 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
11238 {
11239         uint32_t _ptr_attribute_name;
11240         TALLOC_CTX *_mem_save_attribute_name_0;
11241         uint32_t _ptr_originating_dsa_dn;
11242         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11243         if (ndr_flags & NDR_SCALARS) {
11244                 NDR_CHECK(ndr_pull_align(ndr, 8));
11245                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11246                 if (_ptr_attribute_name) {
11247                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11248                 } else {
11249                         r->attribute_name = NULL;
11250                 }
11251                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11252                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11253                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11254                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11255                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11256                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11257                 if (_ptr_originating_dsa_dn) {
11258                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11259                 } else {
11260                         r->originating_dsa_dn = NULL;
11261                 }
11262                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11263         }
11264         if (ndr_flags & NDR_BUFFERS) {
11265                 if (r->attribute_name) {
11266                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11267                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11270                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11271                                 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));
11272                         }
11273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11276                 }
11277                 if (r->originating_dsa_dn) {
11278                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11279                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11281                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11282                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11283                                 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));
11284                         }
11285                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11286                         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));
11287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11288                 }
11289         }
11290         return NDR_ERR_SUCCESS;
11291 }
11292
11293 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2 *r)
11294 {
11295         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2");
11296         ndr->depth++;
11297         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11298         ndr->depth++;
11299         if (r->attribute_name) {
11300                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11301         }
11302         ndr->depth--;
11303         ndr_print_uint32(ndr, "version", r->version);
11304         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11305         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11306         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11307         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11308         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11309         ndr->depth++;
11310         if (r->originating_dsa_dn) {
11311                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11312         }
11313         ndr->depth--;
11314         ndr->depth--;
11315 }
11316
11317 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11318 {
11319         uint32_t cntr_array_0;
11320         if (ndr_flags & NDR_SCALARS) {
11321                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11322                 NDR_CHECK(ndr_push_align(ndr, 8));
11323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11325                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11326                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11327                 }
11328                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11329         }
11330         if (ndr_flags & NDR_BUFFERS) {
11331                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11332                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11333                 }
11334         }
11335         return NDR_ERR_SUCCESS;
11336 }
11337
11338 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11339 {
11340         uint32_t cntr_array_0;
11341         TALLOC_CTX *_mem_save_array_0;
11342         if (ndr_flags & NDR_SCALARS) {
11343                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11344                 NDR_CHECK(ndr_pull_align(ndr, 8));
11345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11347                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11348                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11349                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11350                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11351                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11352                 }
11353                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11354                 if (r->array) {
11355                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11356                 }
11357                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11358         }
11359         if (ndr_flags & NDR_BUFFERS) {
11360                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11361                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11362                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11363                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11364                 }
11365                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11366         }
11367         return NDR_ERR_SUCCESS;
11368 }
11369
11370 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11371 {
11372         uint32_t cntr_array_0;
11373         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2Ctr");
11374         ndr->depth++;
11375         ndr_print_uint32(ndr, "count", r->count);
11376         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11377         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11378         ndr->depth++;
11379         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11380                 char *idx_0=NULL;
11381                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11382                         ndr_print_drsuapi_DsReplicaObjMetaData2(ndr, "array", &r->array[cntr_array_0]);
11383                         free(idx_0);
11384                 }
11385         }
11386         ndr->depth--;
11387         ndr->depth--;
11388 }
11389
11390 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11391 {
11392         if (ndr_flags & NDR_SCALARS) {
11393                 NDR_CHECK(ndr_push_align(ndr, 8));
11394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11397                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11398                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11399                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11401                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11402                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11403                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11404                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11405                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11406                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11407         }
11408         if (ndr_flags & NDR_BUFFERS) {
11409                 if (r->attribute_name) {
11410                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11411                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11412                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11413                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11414                 }
11415                 if (r->object_dn) {
11416                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11417                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11418                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11419                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11420                 }
11421                 if (r->binary) {
11422                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11423                 }
11424                 if (r->originating_dsa_dn) {
11425                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11426                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11427                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11428                         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));
11429                 }
11430         }
11431         return NDR_ERR_SUCCESS;
11432 }
11433
11434 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
11435 {
11436         uint32_t _ptr_attribute_name;
11437         TALLOC_CTX *_mem_save_attribute_name_0;
11438         uint32_t _ptr_object_dn;
11439         TALLOC_CTX *_mem_save_object_dn_0;
11440         uint32_t _ptr_binary;
11441         TALLOC_CTX *_mem_save_binary_0;
11442         uint32_t _ptr_originating_dsa_dn;
11443         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11444         if (ndr_flags & NDR_SCALARS) {
11445                 NDR_CHECK(ndr_pull_align(ndr, 8));
11446                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11447                 if (_ptr_attribute_name) {
11448                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11449                 } else {
11450                         r->attribute_name = NULL;
11451                 }
11452                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11453                 if (_ptr_object_dn) {
11454                         NDR_PULL_ALLOC(ndr, r->object_dn);
11455                 } else {
11456                         r->object_dn = NULL;
11457                 }
11458                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11459                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11460                 if (_ptr_binary) {
11461                         NDR_PULL_ALLOC(ndr, r->binary);
11462                 } else {
11463                         r->binary = NULL;
11464                 }
11465                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11466                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11468                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11469                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11470                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11471                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11472                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11473                 if (_ptr_originating_dsa_dn) {
11474                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11475                 } else {
11476                         r->originating_dsa_dn = NULL;
11477                 }
11478                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11479         }
11480         if (ndr_flags & NDR_BUFFERS) {
11481                 if (r->attribute_name) {
11482                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11483                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11484                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11485                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11486                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11487                                 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));
11488                         }
11489                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11490                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11491                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11492                 }
11493                 if (r->object_dn) {
11494                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11495                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11496                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11497                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11498                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11499                                 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));
11500                         }
11501                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11502                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11503                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11504                 }
11505                 if (r->binary) {
11506                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11507                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11508                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11509                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11510                 }
11511                 if (r->originating_dsa_dn) {
11512                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11513                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11514                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11515                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11516                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11517                                 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));
11518                         }
11519                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11520                         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));
11521                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11522                 }
11523         }
11524         return NDR_ERR_SUCCESS;
11525 }
11526
11527 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11528 {
11529         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2");
11530         ndr->depth++;
11531         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11532         ndr->depth++;
11533         if (r->attribute_name) {
11534                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11535         }
11536         ndr->depth--;
11537         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11538         ndr->depth++;
11539         if (r->object_dn) {
11540                 ndr_print_string(ndr, "object_dn", r->object_dn);
11541         }
11542         ndr->depth--;
11543         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);
11544         ndr_print_ptr(ndr, "binary", r->binary);
11545         ndr->depth++;
11546         if (r->binary) {
11547                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11548         }
11549         ndr->depth--;
11550         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11551         ndr_print_NTTIME(ndr, "created", r->created);
11552         ndr_print_uint32(ndr, "version", r->version);
11553         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11554         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11555         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11556         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11557         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11558         ndr->depth++;
11559         if (r->originating_dsa_dn) {
11560                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11561         }
11562         ndr->depth--;
11563         ndr->depth--;
11564 }
11565
11566 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11567 {
11568         uint32_t cntr_array_0;
11569         if (ndr_flags & NDR_SCALARS) {
11570                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11571                 NDR_CHECK(ndr_push_align(ndr, 8));
11572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11574                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11575                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11576                 }
11577                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11578         }
11579         if (ndr_flags & NDR_BUFFERS) {
11580                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11581                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11582                 }
11583         }
11584         return NDR_ERR_SUCCESS;
11585 }
11586
11587 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11588 {
11589         uint32_t cntr_array_0;
11590         TALLOC_CTX *_mem_save_array_0;
11591         if (ndr_flags & NDR_SCALARS) {
11592                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11593                 NDR_CHECK(ndr_pull_align(ndr, 8));
11594                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11596                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11597                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11598                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11599                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11600                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11601                 }
11602                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11603                 if (r->array) {
11604                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11605                 }
11606                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11607         }
11608         if (ndr_flags & NDR_BUFFERS) {
11609                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11610                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11611                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11612                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11613                 }
11614                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11615         }
11616         return NDR_ERR_SUCCESS;
11617 }
11618
11619 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11620 {
11621         uint32_t cntr_array_0;
11622         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2Ctr");
11623         ndr->depth++;
11624         ndr_print_uint32(ndr, "count", r->count);
11625         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11626         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11627         ndr->depth++;
11628         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11629                 char *idx_0=NULL;
11630                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11631                         ndr_print_drsuapi_DsReplicaAttrValMetaData2(ndr, "array", &r->array[cntr_array_0]);
11632                         free(idx_0);
11633                 }
11634         }
11635         ndr->depth--;
11636         ndr->depth--;
11637 }
11638
11639 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04 *r)
11640 {
11641         if (ndr_flags & NDR_SCALARS) {
11642                 NDR_CHECK(ndr_push_align(ndr, 8));
11643                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u1));
11644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11645                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11646                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11647                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->bind_time));
11648                 {
11649                         uint32_t _flags_save_ipv4address = ndr->flags;
11650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11651                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
11652                         ndr->flags = _flags_save_ipv4address;
11653                 }
11654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11655                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11656         }
11657         if (ndr_flags & NDR_BUFFERS) {
11658         }
11659         return NDR_ERR_SUCCESS;
11660 }
11661
11662 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04 *r)
11663 {
11664         if (ndr_flags & NDR_SCALARS) {
11665                 NDR_CHECK(ndr_pull_align(ndr, 8));
11666                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u1));
11667                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11668                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11669                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11670                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->bind_time));
11671                 {
11672                         uint32_t _flags_save_ipv4address = ndr->flags;
11673                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11674                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
11675                         ndr->flags = _flags_save_ipv4address;
11676                 }
11677                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11678                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11679         }
11680         if (ndr_flags & NDR_BUFFERS) {
11681         }
11682         return NDR_ERR_SUCCESS;
11683 }
11684
11685 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04 *r)
11686 {
11687         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04");
11688         ndr->depth++;
11689         ndr_print_hyper(ndr, "u1", r->u1);
11690         ndr_print_uint32(ndr, "u2", r->u2);
11691         ndr_print_uint32(ndr, "u3", r->u3);
11692         ndr_print_GUID(ndr, "bind_guid", &r->bind_guid);
11693         ndr_print_NTTIME_1sec(ndr, "bind_time", r->bind_time);
11694         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
11695         ndr_print_uint32(ndr, "u5", r->u5);
11696         ndr->depth--;
11697 }
11698
11699 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04Ctr *r)
11700 {
11701         uint32_t cntr_array_0;
11702         if (ndr_flags & NDR_SCALARS) {
11703                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11704                 NDR_CHECK(ndr_push_align(ndr, 8));
11705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11707                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11708                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11709                 }
11710                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11711         }
11712         if (ndr_flags & NDR_BUFFERS) {
11713         }
11714         return NDR_ERR_SUCCESS;
11715 }
11716
11717 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
11718 {
11719         uint32_t cntr_array_0;
11720         TALLOC_CTX *_mem_save_array_0;
11721         if (ndr_flags & NDR_SCALARS) {
11722                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11723                 NDR_CHECK(ndr_pull_align(ndr, 8));
11724                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11725                 if (r->count > 10000) {
11726                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11727                 }
11728                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11729                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11730                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11731                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11732                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11733                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11734                 }
11735                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11736                 if (r->array) {
11737                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11738                 }
11739                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11740         }
11741         if (ndr_flags & NDR_BUFFERS) {
11742         }
11743         return NDR_ERR_SUCCESS;
11744 }
11745
11746 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04Ctr *r)
11747 {
11748         uint32_t cntr_array_0;
11749         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04Ctr");
11750         ndr->depth++;
11751         ndr_print_uint32(ndr, "count", r->count);
11752         ndr_print_uint32(ndr, "reserved", r->reserved);
11753         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11754         ndr->depth++;
11755         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11756                 char *idx_0=NULL;
11757                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11758                         ndr_print_drsuapi_DsReplicaConnection04(ndr, "array", &r->array[cntr_array_0]);
11759                         free(idx_0);
11760                 }
11761         }
11762         ndr->depth--;
11763         ndr->depth--;
11764 }
11765
11766 static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06 *r)
11767 {
11768         if (ndr_flags & NDR_SCALARS) {
11769                 NDR_CHECK(ndr_push_align(ndr, 8));
11770                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str1));
11771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u1));
11772                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u4));
11775                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11776                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
11777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
11778                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11779         }
11780         if (ndr_flags & NDR_BUFFERS) {
11781                 if (r->str1) {
11782                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11783                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11784                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11785                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11786                 }
11787         }
11788         return NDR_ERR_SUCCESS;
11789 }
11790
11791 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
11792 {
11793         uint32_t _ptr_str1;
11794         TALLOC_CTX *_mem_save_str1_0;
11795         if (ndr_flags & NDR_SCALARS) {
11796                 NDR_CHECK(ndr_pull_align(ndr, 8));
11797                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str1));
11798                 if (_ptr_str1) {
11799                         NDR_PULL_ALLOC(ndr, r->str1);
11800                 } else {
11801                         r->str1 = NULL;
11802                 }
11803                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
11804                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11805                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u4));
11807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11808                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
11809                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
11810                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11811         }
11812         if (ndr_flags & NDR_BUFFERS) {
11813                 if (r->str1) {
11814                         _mem_save_str1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11815                         NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
11816                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
11817                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
11818                         if (ndr_get_array_length(ndr, &r->str1) > ndr_get_array_size(ndr, &r->str1)) {
11819                                 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));
11820                         }
11821                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t)));
11822                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t), CH_UTF16));
11823                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
11824                 }
11825         }
11826         return NDR_ERR_SUCCESS;
11827 }
11828
11829 _PUBLIC_ void ndr_print_drsuapi_DsReplica06(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06 *r)
11830 {
11831         ndr_print_struct(ndr, name, "drsuapi_DsReplica06");
11832         ndr->depth++;
11833         ndr_print_ptr(ndr, "str1", r->str1);
11834         ndr->depth++;
11835         if (r->str1) {
11836                 ndr_print_string(ndr, "str1", r->str1);
11837         }
11838         ndr->depth--;
11839         ndr_print_uint32(ndr, "u1", r->u1);
11840         ndr_print_uint32(ndr, "u2", r->u2);
11841         ndr_print_uint32(ndr, "u3", r->u3);
11842         ndr_print_uint32(ndr, "u4", r->u4);
11843         ndr_print_uint32(ndr, "u5", r->u5);
11844         ndr_print_hyper(ndr, "u6", r->u6);
11845         ndr_print_uint32(ndr, "u7", r->u7);
11846         ndr->depth--;
11847 }
11848
11849 static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06Ctr *r)
11850 {
11851         uint32_t cntr_array_0;
11852         if (ndr_flags & NDR_SCALARS) {
11853                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11854                 NDR_CHECK(ndr_push_align(ndr, 8));
11855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11857                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11858                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11859                 }
11860                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11861         }
11862         if (ndr_flags & NDR_BUFFERS) {
11863                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11864                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11865                 }
11866         }
11867         return NDR_ERR_SUCCESS;
11868 }
11869
11870 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *r)
11871 {
11872         uint32_t cntr_array_0;
11873         TALLOC_CTX *_mem_save_array_0;
11874         if (ndr_flags & NDR_SCALARS) {
11875                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11876                 NDR_CHECK(ndr_pull_align(ndr, 8));
11877                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11878                 if (r->count > 256) {
11879                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11880                 }
11881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11882                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11883                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11884                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11885                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11886                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11887                 }
11888                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11889                 if (r->array) {
11890                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11891                 }
11892                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11893         }
11894         if (ndr_flags & NDR_BUFFERS) {
11895                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11896                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11897                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11898                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11899                 }
11900                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11901         }
11902         return NDR_ERR_SUCCESS;
11903 }
11904
11905 _PUBLIC_ void ndr_print_drsuapi_DsReplica06Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06Ctr *r)
11906 {
11907         uint32_t cntr_array_0;
11908         ndr_print_struct(ndr, name, "drsuapi_DsReplica06Ctr");
11909         ndr->depth++;
11910         ndr_print_uint32(ndr, "count", r->count);
11911         ndr_print_uint32(ndr, "reserved", r->reserved);
11912         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11913         ndr->depth++;
11914         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11915                 char *idx_0=NULL;
11916                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11917                         ndr_print_drsuapi_DsReplica06(ndr, "array", &r->array[cntr_array_0]);
11918                         free(idx_0);
11919                 }
11920         }
11921         ndr->depth--;
11922         ndr->depth--;
11923 }
11924
11925 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaInfo *r)
11926 {
11927         if (ndr_flags & NDR_SCALARS) {
11928                 int level = ndr_push_get_switch_value(ndr, r);
11929                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
11930                 NDR_CHECK(ndr_push_union_align(ndr, 5));
11931                 switch (level) {
11932                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
11933                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
11934                         break; }
11935
11936                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
11937                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors));
11938                         break; }
11939
11940                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
11941                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata));
11942                         break; }
11943
11944                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
11945                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connectfailures));
11946                         break; }
11947
11948                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
11949                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linkfailures));
11950                         break; }
11951
11952                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
11953                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pendingops));
11954                         break; }
11955
11956                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
11957                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata));
11958                         break; }
11959
11960                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
11961                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors2));
11962                         break; }
11963
11964                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
11965                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors3));
11966                         break; }
11967
11968                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
11969                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata2));
11970                         break; }
11971
11972                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
11973                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata2));
11974                         break; }
11975
11976                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
11977                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours02));
11978                         break; }
11979
11980                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
11981                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connections04));
11982                         break; }
11983
11984                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
11985                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors05));
11986                         break; }
11987
11988                         case DRSUAPI_DS_REPLICA_INFO_06: {
11989                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->i06));
11990                         break; }
11991
11992                         default:
11993                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
11994                 }
11995         }
11996         if (ndr_flags & NDR_BUFFERS) {
11997                 int level = ndr_push_get_switch_value(ndr, r);
11998                 switch (level) {
11999                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12000                                 if (r->neighbours) {
12001                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12002                                 }
12003                         break;
12004
12005                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12006                                 if (r->cursors) {
12007                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12008                                 }
12009                         break;
12010
12011                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12012                                 if (r->objmetadata) {
12013                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12014                                 }
12015                         break;
12016
12017                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12018                                 if (r->connectfailures) {
12019                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12020                                 }
12021                         break;
12022
12023                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12024                                 if (r->linkfailures) {
12025                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12026                                 }
12027                         break;
12028
12029                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12030                                 if (r->pendingops) {
12031                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12032                                 }
12033                         break;
12034
12035                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12036                                 if (r->attrvalmetadata) {
12037                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12038                                 }
12039                         break;
12040
12041                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12042                                 if (r->cursors2) {
12043                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12044                                 }
12045                         break;
12046
12047                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12048                                 if (r->cursors3) {
12049                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12050                                 }
12051                         break;
12052
12053                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12054                                 if (r->objmetadata2) {
12055                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12056                                 }
12057                         break;
12058
12059                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12060                                 if (r->attrvalmetadata2) {
12061                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12062                                 }
12063                         break;
12064
12065                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12066                                 if (r->neighbours02) {
12067                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12068                                 }
12069                         break;
12070
12071                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12072                                 if (r->connections04) {
12073                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12074                                 }
12075                         break;
12076
12077                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12078                                 if (r->cursors05) {
12079                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12080                                 }
12081                         break;
12082
12083                         case DRSUAPI_DS_REPLICA_INFO_06:
12084                                 if (r->i06) {
12085                                         NDR_CHECK(ndr_push_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12086                                 }
12087                         break;
12088
12089                         default:
12090                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12091                 }
12092         }
12093         return NDR_ERR_SUCCESS;
12094 }
12095
12096 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaInfo *r)
12097 {
12098         int level;
12099         uint32_t _level;
12100         TALLOC_CTX *_mem_save_neighbours_0;
12101         TALLOC_CTX *_mem_save_cursors_0;
12102         TALLOC_CTX *_mem_save_objmetadata_0;
12103         TALLOC_CTX *_mem_save_connectfailures_0;
12104         TALLOC_CTX *_mem_save_linkfailures_0;
12105         TALLOC_CTX *_mem_save_pendingops_0;
12106         TALLOC_CTX *_mem_save_attrvalmetadata_0;
12107         TALLOC_CTX *_mem_save_cursors2_0;
12108         TALLOC_CTX *_mem_save_cursors3_0;
12109         TALLOC_CTX *_mem_save_objmetadata2_0;
12110         TALLOC_CTX *_mem_save_attrvalmetadata2_0;
12111         TALLOC_CTX *_mem_save_neighbours02_0;
12112         TALLOC_CTX *_mem_save_connections04_0;
12113         TALLOC_CTX *_mem_save_cursors05_0;
12114         TALLOC_CTX *_mem_save_i06_0;
12115         level = ndr_pull_get_switch_value(ndr, r);
12116         if (ndr_flags & NDR_SCALARS) {
12117                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12118                 if (_level != level) {
12119                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12120                 }
12121                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12122                 switch (level) {
12123                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12124                                 uint32_t _ptr_neighbours;
12125                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
12126                                 if (_ptr_neighbours) {
12127                                         NDR_PULL_ALLOC(ndr, r->neighbours);
12128                                 } else {
12129                                         r->neighbours = NULL;
12130                                 }
12131                         break; }
12132
12133                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12134                                 uint32_t _ptr_cursors;
12135                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
12136                                 if (_ptr_cursors) {
12137                                         NDR_PULL_ALLOC(ndr, r->cursors);
12138                                 } else {
12139                                         r->cursors = NULL;
12140                                 }
12141                         break; }
12142
12143                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12144                                 uint32_t _ptr_objmetadata;
12145                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
12146                                 if (_ptr_objmetadata) {
12147                                         NDR_PULL_ALLOC(ndr, r->objmetadata);
12148                                 } else {
12149                                         r->objmetadata = NULL;
12150                                 }
12151                         break; }
12152
12153                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12154                                 uint32_t _ptr_connectfailures;
12155                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
12156                                 if (_ptr_connectfailures) {
12157                                         NDR_PULL_ALLOC(ndr, r->connectfailures);
12158                                 } else {
12159                                         r->connectfailures = NULL;
12160                                 }
12161                         break; }
12162
12163                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12164                                 uint32_t _ptr_linkfailures;
12165                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
12166                                 if (_ptr_linkfailures) {
12167                                         NDR_PULL_ALLOC(ndr, r->linkfailures);
12168                                 } else {
12169                                         r->linkfailures = NULL;
12170                                 }
12171                         break; }
12172
12173                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12174                                 uint32_t _ptr_pendingops;
12175                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
12176                                 if (_ptr_pendingops) {
12177                                         NDR_PULL_ALLOC(ndr, r->pendingops);
12178                                 } else {
12179                                         r->pendingops = NULL;
12180                                 }
12181                         break; }
12182
12183                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12184                                 uint32_t _ptr_attrvalmetadata;
12185                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
12186                                 if (_ptr_attrvalmetadata) {
12187                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
12188                                 } else {
12189                                         r->attrvalmetadata = NULL;
12190                                 }
12191                         break; }
12192
12193                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12194                                 uint32_t _ptr_cursors2;
12195                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
12196                                 if (_ptr_cursors2) {
12197                                         NDR_PULL_ALLOC(ndr, r->cursors2);
12198                                 } else {
12199                                         r->cursors2 = NULL;
12200                                 }
12201                         break; }
12202
12203                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12204                                 uint32_t _ptr_cursors3;
12205                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
12206                                 if (_ptr_cursors3) {
12207                                         NDR_PULL_ALLOC(ndr, r->cursors3);
12208                                 } else {
12209                                         r->cursors3 = NULL;
12210                                 }
12211                         break; }
12212
12213                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12214                                 uint32_t _ptr_objmetadata2;
12215                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
12216                                 if (_ptr_objmetadata2) {
12217                                         NDR_PULL_ALLOC(ndr, r->objmetadata2);
12218                                 } else {
12219                                         r->objmetadata2 = NULL;
12220                                 }
12221                         break; }
12222
12223                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12224                                 uint32_t _ptr_attrvalmetadata2;
12225                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
12226                                 if (_ptr_attrvalmetadata2) {
12227                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
12228                                 } else {
12229                                         r->attrvalmetadata2 = NULL;
12230                                 }
12231                         break; }
12232
12233                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
12234                                 uint32_t _ptr_neighbours02;
12235                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours02));
12236                                 if (_ptr_neighbours02) {
12237                                         NDR_PULL_ALLOC(ndr, r->neighbours02);
12238                                 } else {
12239                                         r->neighbours02 = NULL;
12240                                 }
12241                         break; }
12242
12243                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
12244                                 uint32_t _ptr_connections04;
12245                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connections04));
12246                                 if (_ptr_connections04) {
12247                                         NDR_PULL_ALLOC(ndr, r->connections04);
12248                                 } else {
12249                                         r->connections04 = NULL;
12250                                 }
12251                         break; }
12252
12253                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
12254                                 uint32_t _ptr_cursors05;
12255                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors05));
12256                                 if (_ptr_cursors05) {
12257                                         NDR_PULL_ALLOC(ndr, r->cursors05);
12258                                 } else {
12259                                         r->cursors05 = NULL;
12260                                 }
12261                         break; }
12262
12263                         case DRSUAPI_DS_REPLICA_INFO_06: {
12264                                 uint32_t _ptr_i06;
12265                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_i06));
12266                                 if (_ptr_i06) {
12267                                         NDR_PULL_ALLOC(ndr, r->i06);
12268                                 } else {
12269                                         r->i06 = NULL;
12270                                 }
12271                         break; }
12272
12273                         default:
12274                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12275                 }
12276         }
12277         if (ndr_flags & NDR_BUFFERS) {
12278                 switch (level) {
12279                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12280                                 if (r->neighbours) {
12281                                         _mem_save_neighbours_0 = NDR_PULL_GET_MEM_CTX(ndr);
12282                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours, 0);
12283                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12284                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours_0, 0);
12285                                 }
12286                         break;
12287
12288                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12289                                 if (r->cursors) {
12290                                         _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
12291                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
12292                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12293                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
12294                                 }
12295                         break;
12296
12297                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12298                                 if (r->objmetadata) {
12299                                         _mem_save_objmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12300                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata, 0);
12301                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12302                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata_0, 0);
12303                                 }
12304                         break;
12305
12306                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12307                                 if (r->connectfailures) {
12308                                         _mem_save_connectfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12309                                         NDR_PULL_SET_MEM_CTX(ndr, r->connectfailures, 0);
12310                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12311                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connectfailures_0, 0);
12312                                 }
12313                         break;
12314
12315                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12316                                 if (r->linkfailures) {
12317                                         _mem_save_linkfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12318                                         NDR_PULL_SET_MEM_CTX(ndr, r->linkfailures, 0);
12319                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12320                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linkfailures_0, 0);
12321                                 }
12322                         break;
12323
12324                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12325                                 if (r->pendingops) {
12326                                         _mem_save_pendingops_0 = NDR_PULL_GET_MEM_CTX(ndr);
12327                                         NDR_PULL_SET_MEM_CTX(ndr, r->pendingops, 0);
12328                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12329                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pendingops_0, 0);
12330                                 }
12331                         break;
12332
12333                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12334                                 if (r->attrvalmetadata) {
12335                                         _mem_save_attrvalmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12336                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata, 0);
12337                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12338                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata_0, 0);
12339                                 }
12340                         break;
12341
12342                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12343                                 if (r->cursors2) {
12344                                         _mem_save_cursors2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12345                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors2, 0);
12346                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12347                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors2_0, 0);
12348                                 }
12349                         break;
12350
12351                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12352                                 if (r->cursors3) {
12353                                         _mem_save_cursors3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12354                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors3, 0);
12355                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12356                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors3_0, 0);
12357                                 }
12358                         break;
12359
12360                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12361                                 if (r->objmetadata2) {
12362                                         _mem_save_objmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12363                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata2, 0);
12364                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12365                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata2_0, 0);
12366                                 }
12367                         break;
12368
12369                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12370                                 if (r->attrvalmetadata2) {
12371                                         _mem_save_attrvalmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12372                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata2, 0);
12373                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12374                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata2_0, 0);
12375                                 }
12376                         break;
12377
12378                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12379                                 if (r->neighbours02) {
12380                                         _mem_save_neighbours02_0 = NDR_PULL_GET_MEM_CTX(ndr);
12381                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours02, 0);
12382                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12383                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours02_0, 0);
12384                                 }
12385                         break;
12386
12387                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12388                                 if (r->connections04) {
12389                                         _mem_save_connections04_0 = NDR_PULL_GET_MEM_CTX(ndr);
12390                                         NDR_PULL_SET_MEM_CTX(ndr, r->connections04, 0);
12391                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12392                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connections04_0, 0);
12393                                 }
12394                         break;
12395
12396                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12397                                 if (r->cursors05) {
12398                                         _mem_save_cursors05_0 = NDR_PULL_GET_MEM_CTX(ndr);
12399                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors05, 0);
12400                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12401                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors05_0, 0);
12402                                 }
12403                         break;
12404
12405                         case DRSUAPI_DS_REPLICA_INFO_06:
12406                                 if (r->i06) {
12407                                         _mem_save_i06_0 = NDR_PULL_GET_MEM_CTX(ndr);
12408                                         NDR_PULL_SET_MEM_CTX(ndr, r->i06, 0);
12409                                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12410                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_i06_0, 0);
12411                                 }
12412                         break;
12413
12414                         default:
12415                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12416                 }
12417         }
12418         return NDR_ERR_SUCCESS;
12419 }
12420
12421 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaInfo *r)
12422 {
12423         int level;
12424         level = ndr_print_get_switch_value(ndr, r);
12425         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaInfo");
12426         switch (level) {
12427                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12428                         ndr_print_ptr(ndr, "neighbours", r->neighbours);
12429                         ndr->depth++;
12430                         if (r->neighbours) {
12431                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours", r->neighbours);
12432                         }
12433                         ndr->depth--;
12434                 break;
12435
12436                 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12437                         ndr_print_ptr(ndr, "cursors", r->cursors);
12438                         ndr->depth++;
12439                         if (r->cursors) {
12440                                 ndr_print_drsuapi_DsReplicaCursorCtr(ndr, "cursors", r->cursors);
12441                         }
12442                         ndr->depth--;
12443                 break;
12444
12445                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12446                         ndr_print_ptr(ndr, "objmetadata", r->objmetadata);
12447                         ndr->depth++;
12448                         if (r->objmetadata) {
12449                                 ndr_print_drsuapi_DsReplicaObjMetaDataCtr(ndr, "objmetadata", r->objmetadata);
12450                         }
12451                         ndr->depth--;
12452                 break;
12453
12454                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12455                         ndr_print_ptr(ndr, "connectfailures", r->connectfailures);
12456                         ndr->depth++;
12457                         if (r->connectfailures) {
12458                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "connectfailures", r->connectfailures);
12459                         }
12460                         ndr->depth--;
12461                 break;
12462
12463                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12464                         ndr_print_ptr(ndr, "linkfailures", r->linkfailures);
12465                         ndr->depth++;
12466                         if (r->linkfailures) {
12467                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "linkfailures", r->linkfailures);
12468                         }
12469                         ndr->depth--;
12470                 break;
12471
12472                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12473                         ndr_print_ptr(ndr, "pendingops", r->pendingops);
12474                         ndr->depth++;
12475                         if (r->pendingops) {
12476                                 ndr_print_drsuapi_DsReplicaOpCtr(ndr, "pendingops", r->pendingops);
12477                         }
12478                         ndr->depth--;
12479                 break;
12480
12481                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12482                         ndr_print_ptr(ndr, "attrvalmetadata", r->attrvalmetadata);
12483                         ndr->depth++;
12484                         if (r->attrvalmetadata) {
12485                                 ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, "attrvalmetadata", r->attrvalmetadata);
12486                         }
12487                         ndr->depth--;
12488                 break;
12489
12490                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12491                         ndr_print_ptr(ndr, "cursors2", r->cursors2);
12492                         ndr->depth++;
12493                         if (r->cursors2) {
12494                                 ndr_print_drsuapi_DsReplicaCursor2Ctr(ndr, "cursors2", r->cursors2);
12495                         }
12496                         ndr->depth--;
12497                 break;
12498
12499                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12500                         ndr_print_ptr(ndr, "cursors3", r->cursors3);
12501                         ndr->depth++;
12502                         if (r->cursors3) {
12503                                 ndr_print_drsuapi_DsReplicaCursor3Ctr(ndr, "cursors3", r->cursors3);
12504                         }
12505                         ndr->depth--;
12506                 break;
12507
12508                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12509                         ndr_print_ptr(ndr, "objmetadata2", r->objmetadata2);
12510                         ndr->depth++;
12511                         if (r->objmetadata2) {
12512                                 ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(ndr, "objmetadata2", r->objmetadata2);
12513                         }
12514                         ndr->depth--;
12515                 break;
12516
12517                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12518                         ndr_print_ptr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12519                         ndr->depth++;
12520                         if (r->attrvalmetadata2) {
12521                                 ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12522                         }
12523                         ndr->depth--;
12524                 break;
12525
12526                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12527                         ndr_print_ptr(ndr, "neighbours02", r->neighbours02);
12528                         ndr->depth++;
12529                         if (r->neighbours02) {
12530                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours02", r->neighbours02);
12531                         }
12532                         ndr->depth--;
12533                 break;
12534
12535                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12536                         ndr_print_ptr(ndr, "connections04", r->connections04);
12537                         ndr->depth++;
12538                         if (r->connections04) {
12539                                 ndr_print_drsuapi_DsReplicaConnection04Ctr(ndr, "connections04", r->connections04);
12540                         }
12541                         ndr->depth--;
12542                 break;
12543
12544                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12545                         ndr_print_ptr(ndr, "cursors05", r->cursors05);
12546                         ndr->depth++;
12547                         if (r->cursors05) {
12548                                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "cursors05", r->cursors05);
12549                         }
12550                         ndr->depth--;
12551                 break;
12552
12553                 case DRSUAPI_DS_REPLICA_INFO_06:
12554                         ndr_print_ptr(ndr, "i06", r->i06);
12555                         ndr->depth++;
12556                         if (r->i06) {
12557                                 ndr_print_drsuapi_DsReplica06Ctr(ndr, "i06", r->i06);
12558                         }
12559                         ndr->depth--;
12560                 break;
12561
12562                 default:
12563                         ndr_print_bad_level(ndr, name, level);
12564         }
12565 }
12566
12567 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Ctr *r)
12568 {
12569         if (ndr_flags & NDR_SCALARS) {
12570                 int level = ndr_push_get_switch_value(ndr, r);
12571                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12572                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12573                 switch (level) {
12574                         case 1: {
12575                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12576                         break; }
12577
12578                         default:
12579                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12580                 }
12581         }
12582         if (ndr_flags & NDR_BUFFERS) {
12583                 int level = ndr_push_get_switch_value(ndr, r);
12584                 switch (level) {
12585                         case 1:
12586                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12587                         break;
12588
12589                         default:
12590                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12591                 }
12592         }
12593         return NDR_ERR_SUCCESS;
12594 }
12595
12596 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Ctr *r)
12597 {
12598         int level;
12599         int32_t _level;
12600         level = ndr_pull_get_switch_value(ndr, r);
12601         if (ndr_flags & NDR_SCALARS) {
12602                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12603                 if (_level != level) {
12604                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12605                 }
12606                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12607                 switch (level) {
12608                         case 1: {
12609                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12610                         break; }
12611
12612                         default:
12613                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12614                 }
12615         }
12616         if (ndr_flags & NDR_BUFFERS) {
12617                 switch (level) {
12618                         case 1:
12619                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12620                         break;
12621
12622                         default:
12623                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12624                 }
12625         }
12626         return NDR_ERR_SUCCESS;
12627 }
12628
12629 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Ctr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Ctr *r)
12630 {
12631         int level;
12632         level = ndr_print_get_switch_value(ndr, r);
12633         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Ctr");
12634         switch (level) {
12635                 case 1:
12636                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
12637                 break;
12638
12639                 default:
12640                         ndr_print_bad_level(ndr, name, level);
12641         }
12642 }
12643
12644 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMemberships2Request1 *r)
12645 {
12646         uint32_t cntr_req_array_1;
12647         if (ndr_flags & NDR_SCALARS) {
12648                 NDR_CHECK(ndr_push_align(ndr, 5));
12649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12650                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
12651                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12652         }
12653         if (ndr_flags & NDR_BUFFERS) {
12654                 if (r->req_array) {
12655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
12656                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12657                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
12658                         }
12659                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12660                                 if (r->req_array[cntr_req_array_1]) {
12661                                         NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12662                                 }
12663                         }
12664                 }
12665         }
12666         return NDR_ERR_SUCCESS;
12667 }
12668
12669 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
12670 {
12671         uint32_t _ptr_req_array;
12672         uint32_t cntr_req_array_1;
12673         TALLOC_CTX *_mem_save_req_array_0;
12674         TALLOC_CTX *_mem_save_req_array_1;
12675         TALLOC_CTX *_mem_save_req_array_2;
12676         if (ndr_flags & NDR_SCALARS) {
12677                 NDR_CHECK(ndr_pull_align(ndr, 5));
12678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12679                 if (r->num_req < 1 || r->num_req > 10000) {
12680                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12681                 }
12682                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12683                 if (_ptr_req_array) {
12684                         NDR_PULL_ALLOC(ndr, r->req_array);
12685                 } else {
12686                         r->req_array = NULL;
12687                 }
12688                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12689         }
12690         if (ndr_flags & NDR_BUFFERS) {
12691                 if (r->req_array) {
12692                         _mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12693                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12694                         NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
12695                         NDR_PULL_ALLOC_N(ndr, r->req_array, ndr_get_array_size(ndr, &r->req_array));
12696                         _mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12697                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12698                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12699                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12700                                 if (_ptr_req_array) {
12701                                         NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
12702                                 } else {
12703                                         r->req_array[cntr_req_array_1] = NULL;
12704                                 }
12705                         }
12706                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12707                                 if (r->req_array[cntr_req_array_1]) {
12708                                         _mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
12709                                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
12710                                         NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12711                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_2, 0);
12712                                 }
12713                         }
12714                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_1, 0);
12715                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_0, 0);
12716                 }
12717                 if (r->req_array) {
12718                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->req_array, r->num_req));
12719                 }
12720         }
12721         return NDR_ERR_SUCCESS;
12722 }
12723
12724 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMemberships2Request1 *r)
12725 {
12726         uint32_t cntr_req_array_1;
12727         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2Request1");
12728         ndr->depth++;
12729         ndr_print_uint32(ndr, "num_req", r->num_req);
12730         ndr_print_ptr(ndr, "req_array", r->req_array);
12731         ndr->depth++;
12732         if (r->req_array) {
12733                 ndr->print(ndr, "%s: ARRAY(%d)", "req_array", (int)r->num_req);
12734                 ndr->depth++;
12735                 for (cntr_req_array_1=0;cntr_req_array_1<r->num_req;cntr_req_array_1++) {
12736                         char *idx_1=NULL;
12737                         if (asprintf(&idx_1, "[%d]", cntr_req_array_1) != -1) {
12738                                 ndr_print_ptr(ndr, "req_array", r->req_array[cntr_req_array_1]);
12739                                 ndr->depth++;
12740                                 if (r->req_array[cntr_req_array_1]) {
12741                                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req_array", r->req_array[cntr_req_array_1]);
12742                                 }
12743                                 ndr->depth--;
12744                                 free(idx_1);
12745                         }
12746                 }
12747                 ndr->depth--;
12748         }
12749         ndr->depth--;
12750         ndr->depth--;
12751 }
12752
12753 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Request *r)
12754 {
12755         if (ndr_flags & NDR_SCALARS) {
12756                 int level = ndr_push_get_switch_value(ndr, r);
12757                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12758                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12759                 switch (level) {
12760                         case 1: {
12761                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12762                         break; }
12763
12764                         default:
12765                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12766                 }
12767         }
12768         if (ndr_flags & NDR_BUFFERS) {
12769                 int level = ndr_push_get_switch_value(ndr, r);
12770                 switch (level) {
12771                         case 1:
12772                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12773                         break;
12774
12775                         default:
12776                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12777                 }
12778         }
12779         return NDR_ERR_SUCCESS;
12780 }
12781
12782 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Request *r)
12783 {
12784         int level;
12785         int32_t _level;
12786         level = ndr_pull_get_switch_value(ndr, r);
12787         if (ndr_flags & NDR_SCALARS) {
12788                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12789                 if (_level != level) {
12790                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12791                 }
12792                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12793                 switch (level) {
12794                         case 1: {
12795                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12796                         break; }
12797
12798                         default:
12799                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12800                 }
12801         }
12802         if (ndr_flags & NDR_BUFFERS) {
12803                 switch (level) {
12804                         case 1:
12805                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12806                         break;
12807
12808                         default:
12809                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12810                 }
12811         }
12812         return NDR_ERR_SUCCESS;
12813 }
12814
12815 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Request *r)
12816 {
12817         int level;
12818         level = ndr_print_get_switch_value(ndr, r);
12819         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Request");
12820         switch (level) {
12821                 case 1:
12822                         ndr_print_drsuapi_DsGetMemberships2Request1(ndr, "req1", &r->req1);
12823                 break;
12824
12825                 default:
12826                         ndr_print_bad_level(ndr, name, level);
12827         }
12828 }
12829
12830 static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsSiteCostInfo *r)
12831 {
12832         if (ndr_flags & NDR_SCALARS) {
12833                 NDR_CHECK(ndr_push_align(ndr, 4));
12834                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
12835                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
12836                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
12837         }
12838         if (ndr_flags & NDR_BUFFERS) {
12839         }
12840         return NDR_ERR_SUCCESS;
12841 }
12842
12843 static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsSiteCostInfo *r)
12844 {
12845         if (ndr_flags & NDR_SCALARS) {
12846                 NDR_CHECK(ndr_pull_align(ndr, 4));
12847                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
12848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
12849                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
12850         }
12851         if (ndr_flags & NDR_BUFFERS) {
12852         }
12853         return NDR_ERR_SUCCESS;
12854 }
12855
12856 _PUBLIC_ void ndr_print_drsuapi_DsSiteCostInfo(struct ndr_print *ndr, const char *name, const struct drsuapi_DsSiteCostInfo *r)
12857 {
12858         ndr_print_struct(ndr, name, "drsuapi_DsSiteCostInfo");
12859         ndr->depth++;
12860         ndr_print_WERROR(ndr, "error_code", r->error_code);
12861         ndr_print_uint32(ndr, "site_cost", r->site_cost);
12862         ndr->depth--;
12863 }
12864
12865 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostCtr1 *r)
12866 {
12867         uint32_t cntr_info_1;
12868         if (ndr_flags & NDR_SCALARS) {
12869                 NDR_CHECK(ndr_push_align(ndr, 5));
12870                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
12871                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
12872                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
12873                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12874         }
12875         if (ndr_flags & NDR_BUFFERS) {
12876                 if (r->info) {
12877                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_info));
12878                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12879                                 NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12880                         }
12881                 }
12882         }
12883         return NDR_ERR_SUCCESS;
12884 }
12885
12886 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
12887 {
12888         uint32_t _ptr_info;
12889         uint32_t cntr_info_1;
12890         TALLOC_CTX *_mem_save_info_0;
12891         TALLOC_CTX *_mem_save_info_1;
12892         if (ndr_flags & NDR_SCALARS) {
12893                 NDR_CHECK(ndr_pull_align(ndr, 5));
12894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
12895                 if (r->num_info > 10000) {
12896                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12897                 }
12898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12899                 if (_ptr_info) {
12900                         NDR_PULL_ALLOC(ndr, r->info);
12901                 } else {
12902                         r->info = NULL;
12903                 }
12904                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
12905                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12906         }
12907         if (ndr_flags & NDR_BUFFERS) {
12908                 if (r->info) {
12909                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12910                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12911                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
12912                         NDR_PULL_ALLOC_N(ndr, r->info, ndr_get_array_size(ndr, &r->info));
12913                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
12914                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12915                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12916                                 NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12917                         }
12918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
12919                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12920                 }
12921                 if (r->info) {
12922                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info, r->num_info));
12923                 }
12924         }
12925         return NDR_ERR_SUCCESS;
12926 }
12927
12928 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostCtr1 *r)
12929 {
12930         uint32_t cntr_info_1;
12931         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostCtr1");
12932         ndr->depth++;
12933         ndr_print_uint32(ndr, "num_info", r->num_info);
12934         ndr_print_ptr(ndr, "info", r->info);
12935         ndr->depth++;
12936         if (r->info) {
12937                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->num_info);
12938                 ndr->depth++;
12939                 for (cntr_info_1=0;cntr_info_1<r->num_info;cntr_info_1++) {
12940                         char *idx_1=NULL;
12941                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12942                                 ndr_print_drsuapi_DsSiteCostInfo(ndr, "info", &r->info[cntr_info_1]);
12943                                 free(idx_1);
12944                         }
12945                 }
12946                 ndr->depth--;
12947         }
12948         ndr->depth--;
12949         ndr_print_uint32(ndr, "unknown", r->unknown);
12950         ndr->depth--;
12951 }
12952
12953 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostCtr *r)
12954 {
12955         if (ndr_flags & NDR_SCALARS) {
12956                 int level = ndr_push_get_switch_value(ndr, r);
12957                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12958                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12959                 switch (level) {
12960                         case 1: {
12961                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12962                         break; }
12963
12964                         default:
12965                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12966                 }
12967         }
12968         if (ndr_flags & NDR_BUFFERS) {
12969                 int level = ndr_push_get_switch_value(ndr, r);
12970                 switch (level) {
12971                         case 1:
12972                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12973                         break;
12974
12975                         default:
12976                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12977                 }
12978         }
12979         return NDR_ERR_SUCCESS;
12980 }
12981
12982 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostCtr *r)
12983 {
12984         int level;
12985         int32_t _level;
12986         level = ndr_pull_get_switch_value(ndr, r);
12987         if (ndr_flags & NDR_SCALARS) {
12988                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12989                 if (_level != level) {
12990                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12991                 }
12992                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12993                 switch (level) {
12994                         case 1: {
12995                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12996                         break; }
12997
12998                         default:
12999                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13000                 }
13001         }
13002         if (ndr_flags & NDR_BUFFERS) {
13003                 switch (level) {
13004                         case 1:
13005                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
13006                         break;
13007
13008                         default:
13009                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13010                 }
13011         }
13012         return NDR_ERR_SUCCESS;
13013 }
13014
13015 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostCtr *r)
13016 {
13017         int level;
13018         level = ndr_print_get_switch_value(ndr, r);
13019         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostCtr");
13020         switch (level) {
13021                 case 1:
13022                         ndr_print_drsuapi_QuerySitesByCostCtr1(ndr, "ctr1", &r->ctr1);
13023                 break;
13024
13025                 default:
13026                         ndr_print_bad_level(ndr, name, level);
13027         }
13028 }
13029
13030 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostRequest1 *r)
13031 {
13032         uint32_t cntr_site_to_1;
13033         if (ndr_flags & NDR_SCALARS) {
13034                 NDR_CHECK(ndr_push_align(ndr, 5));
13035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
13036                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
13037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
13038                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13039                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13040         }
13041         if (ndr_flags & NDR_BUFFERS) {
13042                 if (r->site_from) {
13043                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13044                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13045                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13046                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13047                 }
13048                 if (r->site_to) {
13049                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
13050                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13051                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
13052                         }
13053                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13054                                 if (r->site_to[cntr_site_to_1]) {
13055                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13056                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
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_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));
13059                                 }
13060                         }
13061                 }
13062         }
13063         return NDR_ERR_SUCCESS;
13064 }
13065
13066 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
13067 {
13068         uint32_t _ptr_site_from;
13069         TALLOC_CTX *_mem_save_site_from_0;
13070         uint32_t _ptr_site_to;
13071         uint32_t cntr_site_to_1;
13072         TALLOC_CTX *_mem_save_site_to_0;
13073         TALLOC_CTX *_mem_save_site_to_1;
13074         TALLOC_CTX *_mem_save_site_to_2;
13075         if (ndr_flags & NDR_SCALARS) {
13076                 NDR_CHECK(ndr_pull_align(ndr, 5));
13077                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
13078                 if (_ptr_site_from) {
13079                         NDR_PULL_ALLOC(ndr, r->site_from);
13080                 } else {
13081                         r->site_from = NULL;
13082                 }
13083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
13084                 if (r->num_req < 1 || r->num_req > 10000) {
13085                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
13086                 }
13087                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13088                 if (_ptr_site_to) {
13089                         NDR_PULL_ALLOC(ndr, r->site_to);
13090                 } else {
13091                         r->site_to = NULL;
13092                 }
13093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13094                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13095         }
13096         if (ndr_flags & NDR_BUFFERS) {
13097                 if (r->site_from) {
13098                         _mem_save_site_from_0 = NDR_PULL_GET_MEM_CTX(ndr);
13099                         NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
13100                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
13101                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
13102                         if (ndr_get_array_length(ndr, &r->site_from) > ndr_get_array_size(ndr, &r->site_from)) {
13103                                 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));
13104                         }
13105                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t)));
13106                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t), CH_UTF16));
13107                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
13108                 }
13109                 if (r->site_to) {
13110                         _mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
13111                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13112                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
13113                         NDR_PULL_ALLOC_N(ndr, r->site_to, ndr_get_array_size(ndr, &r->site_to));
13114                         _mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
13115                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13116                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13117                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13118                                 if (_ptr_site_to) {
13119                                         NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
13120                                 } else {
13121                                         r->site_to[cntr_site_to_1] = NULL;
13122                                 }
13123                         }
13124                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13125                                 if (r->site_to[cntr_site_to_1]) {
13126                                         _mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
13127                                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
13128                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
13129                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
13130                                         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])) {
13131                                                 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]));
13132                                         }
13133                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t)));
13134                                         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));
13135                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
13136                                 }
13137                         }
13138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_1, 0);
13139                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_0, 0);
13140                 }
13141                 if (r->site_to) {
13142                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->site_to, r->num_req));
13143                 }
13144         }
13145         return NDR_ERR_SUCCESS;
13146 }
13147
13148 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostRequest1 *r)
13149 {
13150         uint32_t cntr_site_to_1;
13151         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostRequest1");
13152         ndr->depth++;
13153         ndr_print_ptr(ndr, "site_from", r->site_from);
13154         ndr->depth++;
13155         if (r->site_from) {
13156                 ndr_print_string(ndr, "site_from", r->site_from);
13157         }
13158         ndr->depth--;
13159         ndr_print_uint32(ndr, "num_req", r->num_req);
13160         ndr_print_ptr(ndr, "site_to", r->site_to);
13161         ndr->depth++;
13162         if (r->site_to) {
13163                 ndr->print(ndr, "%s: ARRAY(%d)", "site_to", (int)r->num_req);
13164                 ndr->depth++;
13165                 for (cntr_site_to_1=0;cntr_site_to_1<r->num_req;cntr_site_to_1++) {
13166                         char *idx_1=NULL;
13167                         if (asprintf(&idx_1, "[%d]", cntr_site_to_1) != -1) {
13168                                 ndr_print_ptr(ndr, "site_to", r->site_to[cntr_site_to_1]);
13169                                 ndr->depth++;
13170                                 if (r->site_to[cntr_site_to_1]) {
13171                                         ndr_print_string(ndr, "site_to", r->site_to[cntr_site_to_1]);
13172                                 }
13173                                 ndr->depth--;
13174                                 free(idx_1);
13175                         }
13176                 }
13177                 ndr->depth--;
13178         }
13179         ndr->depth--;
13180         ndr_print_uint32(ndr, "flags", r->flags);
13181         ndr->depth--;
13182 }
13183
13184 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostRequest *r)
13185 {
13186         if (ndr_flags & NDR_SCALARS) {
13187                 int level = ndr_push_get_switch_value(ndr, r);
13188                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13189                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13190                 switch (level) {
13191                         case 1: {
13192                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13193                         break; }
13194
13195                         default:
13196                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13197                 }
13198         }
13199         if (ndr_flags & NDR_BUFFERS) {
13200                 int level = ndr_push_get_switch_value(ndr, r);
13201                 switch (level) {
13202                         case 1:
13203                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13204                         break;
13205
13206                         default:
13207                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13208                 }
13209         }
13210         return NDR_ERR_SUCCESS;
13211 }
13212
13213 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostRequest *r)
13214 {
13215         int level;
13216         int32_t _level;
13217         level = ndr_pull_get_switch_value(ndr, r);
13218         if (ndr_flags & NDR_SCALARS) {
13219                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13220                 if (_level != level) {
13221                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13222                 }
13223                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13224                 switch (level) {
13225                         case 1: {
13226                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13227                         break; }
13228
13229                         default:
13230                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13231                 }
13232         }
13233         if (ndr_flags & NDR_BUFFERS) {
13234                 switch (level) {
13235                         case 1:
13236                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13237                         break;
13238
13239                         default:
13240                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13241                 }
13242         }
13243         return NDR_ERR_SUCCESS;
13244 }
13245
13246 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostRequest *r)
13247 {
13248         int level;
13249         level = ndr_print_get_switch_value(ndr, r);
13250         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostRequest");
13251         switch (level) {
13252                 case 1:
13253                         ndr_print_drsuapi_QuerySitesByCostRequest1(ndr, "req1", &r->req1);
13254                 break;
13255
13256                 default:
13257                         ndr_print_bad_level(ndr, name, level);
13258         }
13259 }
13260
13261 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsBind(struct ndr_push *ndr, int flags, const struct drsuapi_DsBind *r)
13262 {
13263         if (flags & NDR_IN) {
13264                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_guid));
13265                 if (r->in.bind_guid) {
13266                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13267                 }
13268                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_info));
13269                 if (r->in.bind_info) {
13270                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13271                 }
13272         }
13273         if (flags & NDR_OUT) {
13274                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.bind_info));
13275                 if (r->out.bind_info) {
13276                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13277                 }
13278                 if (r->out.bind_handle == NULL) {
13279                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13280                 }
13281                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13282                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13283         }
13284         return NDR_ERR_SUCCESS;
13285 }
13286
13287 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsBind(struct ndr_pull *ndr, int flags, struct drsuapi_DsBind *r)
13288 {
13289         uint32_t _ptr_bind_guid;
13290         uint32_t _ptr_bind_info;
13291         TALLOC_CTX *_mem_save_bind_guid_0;
13292         TALLOC_CTX *_mem_save_bind_info_0;
13293         TALLOC_CTX *_mem_save_bind_handle_0;
13294         if (flags & NDR_IN) {
13295                 ZERO_STRUCT(r->out);
13296
13297                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_guid));
13298                 if (_ptr_bind_guid) {
13299                         NDR_PULL_ALLOC(ndr, r->in.bind_guid);
13300                 } else {
13301                         r->in.bind_guid = NULL;
13302                 }
13303                 if (r->in.bind_guid) {
13304                         _mem_save_bind_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
13305                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_guid, 0);
13306                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13307                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_guid_0, 0);
13308                 }
13309                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13310                 if (_ptr_bind_info) {
13311                         NDR_PULL_ALLOC(ndr, r->in.bind_info);
13312                 } else {
13313                         r->in.bind_info = NULL;
13314                 }
13315                 if (r->in.bind_info) {
13316                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13317                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_info, 0);
13318                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13319                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13320                 }
13321                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13322                 ZERO_STRUCTP(r->out.bind_handle);
13323         }
13324         if (flags & NDR_OUT) {
13325                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13326                 if (_ptr_bind_info) {
13327                         NDR_PULL_ALLOC(ndr, r->out.bind_info);
13328                 } else {
13329                         r->out.bind_info = NULL;
13330                 }
13331                 if (r->out.bind_info) {
13332                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13333                         NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_info, 0);
13334                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13335                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13336                 }
13337                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13338                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13339                 }
13340                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13341                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13342                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13343                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13344                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13345         }
13346         return NDR_ERR_SUCCESS;
13347 }
13348
13349 _PUBLIC_ void ndr_print_drsuapi_DsBind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsBind *r)
13350 {
13351         ndr_print_struct(ndr, name, "drsuapi_DsBind");
13352         ndr->depth++;
13353         if (flags & NDR_SET_VALUES) {
13354                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13355         }
13356         if (flags & NDR_IN) {
13357                 ndr_print_struct(ndr, "in", "drsuapi_DsBind");
13358                 ndr->depth++;
13359                 ndr_print_ptr(ndr, "bind_guid", r->in.bind_guid);
13360                 ndr->depth++;
13361                 if (r->in.bind_guid) {
13362                         ndr_print_GUID(ndr, "bind_guid", r->in.bind_guid);
13363                 }
13364                 ndr->depth--;
13365                 ndr_print_ptr(ndr, "bind_info", r->in.bind_info);
13366                 ndr->depth++;
13367                 if (r->in.bind_info) {
13368                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->in.bind_info);
13369                 }
13370                 ndr->depth--;
13371                 ndr->depth--;
13372         }
13373         if (flags & NDR_OUT) {
13374                 ndr_print_struct(ndr, "out", "drsuapi_DsBind");
13375                 ndr->depth++;
13376                 ndr_print_ptr(ndr, "bind_info", r->out.bind_info);
13377                 ndr->depth++;
13378                 if (r->out.bind_info) {
13379                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->out.bind_info);
13380                 }
13381                 ndr->depth--;
13382                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13383                 ndr->depth++;
13384                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13385                 ndr->depth--;
13386                 ndr_print_WERROR(ndr, "result", r->out.result);
13387                 ndr->depth--;
13388         }
13389         ndr->depth--;
13390 }
13391
13392 static enum ndr_err_code ndr_push_drsuapi_DsUnbind(struct ndr_push *ndr, int flags, const struct drsuapi_DsUnbind *r)
13393 {
13394         if (flags & NDR_IN) {
13395                 if (r->in.bind_handle == NULL) {
13396                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13397                 }
13398                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13399         }
13400         if (flags & NDR_OUT) {
13401                 if (r->out.bind_handle == NULL) {
13402                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13403                 }
13404                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13405                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13406         }
13407         return NDR_ERR_SUCCESS;
13408 }
13409
13410 static enum ndr_err_code ndr_pull_drsuapi_DsUnbind(struct ndr_pull *ndr, int flags, struct drsuapi_DsUnbind *r)
13411 {
13412         TALLOC_CTX *_mem_save_bind_handle_0;
13413         if (flags & NDR_IN) {
13414                 ZERO_STRUCT(r->out);
13415
13416                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13417                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13418                 }
13419                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13420                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13421                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13422                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13423                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13424                 *r->out.bind_handle = *r->in.bind_handle;
13425         }
13426         if (flags & NDR_OUT) {
13427                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13428                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13429                 }
13430                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13431                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13432                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13433                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13434                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13435         }
13436         return NDR_ERR_SUCCESS;
13437 }
13438
13439 _PUBLIC_ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsUnbind *r)
13440 {
13441         ndr_print_struct(ndr, name, "drsuapi_DsUnbind");
13442         ndr->depth++;
13443         if (flags & NDR_SET_VALUES) {
13444                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13445         }
13446         if (flags & NDR_IN) {
13447                 ndr_print_struct(ndr, "in", "drsuapi_DsUnbind");
13448                 ndr->depth++;
13449                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13450                 ndr->depth++;
13451                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13452                 ndr->depth--;
13453                 ndr->depth--;
13454         }
13455         if (flags & NDR_OUT) {
13456                 ndr_print_struct(ndr, "out", "drsuapi_DsUnbind");
13457                 ndr->depth++;
13458                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13459                 ndr->depth++;
13460                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13461                 ndr->depth--;
13462                 ndr_print_WERROR(ndr, "result", r->out.result);
13463                 ndr->depth--;
13464         }
13465         ndr->depth--;
13466 }
13467
13468 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSync(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaSync *r)
13469 {
13470         if (flags & NDR_IN) {
13471                 if (r->in.bind_handle == NULL) {
13472                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13473                 }
13474                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13475                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13476                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13477                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13478         }
13479         if (flags & NDR_OUT) {
13480                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13481         }
13482         return NDR_ERR_SUCCESS;
13483 }
13484
13485 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSync(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaSync *r)
13486 {
13487         TALLOC_CTX *_mem_save_bind_handle_0;
13488         if (flags & NDR_IN) {
13489                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13490                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13491                 }
13492                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13493                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13494                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13495                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13496                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13497                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13498                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13499         }
13500         if (flags & NDR_OUT) {
13501                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13502         }
13503         return NDR_ERR_SUCCESS;
13504 }
13505
13506 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r)
13507 {
13508         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSync");
13509         ndr->depth++;
13510         if (flags & NDR_SET_VALUES) {
13511                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13512         }
13513         if (flags & NDR_IN) {
13514                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaSync");
13515                 ndr->depth++;
13516                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13517                 ndr->depth++;
13518                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13519                 ndr->depth--;
13520                 ndr_print_int32(ndr, "level", r->in.level);
13521                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13522                 ndr_print_drsuapi_DsReplicaSyncRequest(ndr, "req", &r->in.req);
13523                 ndr->depth--;
13524         }
13525         if (flags & NDR_OUT) {
13526                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaSync");
13527                 ndr->depth++;
13528                 ndr_print_WERROR(ndr, "result", r->out.result);
13529                 ndr->depth--;
13530         }
13531         ndr->depth--;
13532 }
13533
13534 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChanges(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNCChanges *r)
13535 {
13536         if (flags & NDR_IN) {
13537                 if (r->in.bind_handle == NULL) {
13538                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13539                 }
13540                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13541                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13542                 if (r->in.req == NULL) {
13543                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13544                 }
13545                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13546                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13547         }
13548         if (flags & NDR_OUT) {
13549                 if (r->out.level_out == NULL) {
13550                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13551                 }
13552                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13553                 if (r->out.ctr == NULL) {
13554                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13555                 }
13556                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13557                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13558                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13559         }
13560         return NDR_ERR_SUCCESS;
13561 }
13562
13563 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChanges(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNCChanges *r)
13564 {
13565         TALLOC_CTX *_mem_save_bind_handle_0;
13566         TALLOC_CTX *_mem_save_req_0;
13567         TALLOC_CTX *_mem_save_level_out_0;
13568         TALLOC_CTX *_mem_save_ctr_0;
13569         if (flags & NDR_IN) {
13570                 ZERO_STRUCT(r->out);
13571
13572                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13573                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13574                 }
13575                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13576                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13577                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13578                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13579                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13580                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13581                         NDR_PULL_ALLOC(ndr, r->in.req);
13582                 }
13583                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13584                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13585                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13586                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13587                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13588                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13589                 ZERO_STRUCTP(r->out.level_out);
13590                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13591                 ZERO_STRUCTP(r->out.ctr);
13592         }
13593         if (flags & NDR_OUT) {
13594                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13595                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13596                 }
13597                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13598                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13599                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13600                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13601                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13602                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13603                 }
13604                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13605                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13606                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13607                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13608                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13609                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13610         }
13611         return NDR_ERR_SUCCESS;
13612 }
13613
13614 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r)
13615 {
13616         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChanges");
13617         ndr->depth++;
13618         if (flags & NDR_SET_VALUES) {
13619                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13620         }
13621         if (flags & NDR_IN) {
13622                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNCChanges");
13623                 ndr->depth++;
13624                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13625                 ndr->depth++;
13626                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13627                 ndr->depth--;
13628                 ndr_print_int32(ndr, "level", r->in.level);
13629                 ndr_print_ptr(ndr, "req", r->in.req);
13630                 ndr->depth++;
13631                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13632                 ndr_print_drsuapi_DsGetNCChangesRequest(ndr, "req", r->in.req);
13633                 ndr->depth--;
13634                 ndr->depth--;
13635         }
13636         if (flags & NDR_OUT) {
13637                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNCChanges");
13638                 ndr->depth++;
13639                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13640                 ndr->depth++;
13641                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13642                 ndr->depth--;
13643                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13644                 ndr->depth++;
13645                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13646                 ndr_print_drsuapi_DsGetNCChangesCtr(ndr, "ctr", r->out.ctr);
13647                 ndr->depth--;
13648                 ndr_print_WERROR(ndr, "result", r->out.result);
13649                 ndr->depth--;
13650         }
13651         ndr->depth--;
13652 }
13653
13654 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefs(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13655 {
13656         if (flags & NDR_IN) {
13657                 if (r->in.bind_handle == NULL) {
13658                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13659                 }
13660                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13661                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13662                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13663                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13664         }
13665         if (flags & NDR_OUT) {
13666                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13667         }
13668         return NDR_ERR_SUCCESS;
13669 }
13670
13671 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefs(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaUpdateRefs *r)
13672 {
13673         TALLOC_CTX *_mem_save_bind_handle_0;
13674         if (flags & NDR_IN) {
13675                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13676                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13677                 }
13678                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13679                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13680                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13681                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13682                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13683                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13684                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13685         }
13686         if (flags & NDR_OUT) {
13687                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13688         }
13689         return NDR_ERR_SUCCESS;
13690 }
13691
13692 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13693 {
13694         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefs");
13695         ndr->depth++;
13696         if (flags & NDR_SET_VALUES) {
13697                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13698         }
13699         if (flags & NDR_IN) {
13700                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaUpdateRefs");
13701                 ndr->depth++;
13702                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13703                 ndr->depth++;
13704                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13705                 ndr->depth--;
13706                 ndr_print_int32(ndr, "level", r->in.level);
13707                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13708                 ndr_print_drsuapi_DsReplicaUpdateRefsRequest(ndr, "req", &r->in.req);
13709                 ndr->depth--;
13710         }
13711         if (flags & NDR_OUT) {
13712                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaUpdateRefs");
13713                 ndr->depth++;
13714                 ndr_print_WERROR(ndr, "result", r->out.result);
13715                 ndr->depth--;
13716         }
13717         ndr->depth--;
13718 }
13719
13720 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAdd(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaAdd *r)
13721 {
13722         if (flags & NDR_IN) {
13723                 if (r->in.bind_handle == NULL) {
13724                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13725                 }
13726                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13727                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13728                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13729                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13730         }
13731         if (flags & NDR_OUT) {
13732                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13733         }
13734         return NDR_ERR_SUCCESS;
13735 }
13736
13737 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAdd(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaAdd *r)
13738 {
13739         TALLOC_CTX *_mem_save_bind_handle_0;
13740         if (flags & NDR_IN) {
13741                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13742                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13743                 }
13744                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13745                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13746                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13747                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13748                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13749                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13750                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13751         }
13752         if (flags & NDR_OUT) {
13753                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13754         }
13755         return NDR_ERR_SUCCESS;
13756 }
13757
13758 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r)
13759 {
13760         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAdd");
13761         ndr->depth++;
13762         if (flags & NDR_SET_VALUES) {
13763                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13764         }
13765         if (flags & NDR_IN) {
13766                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaAdd");
13767                 ndr->depth++;
13768                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13769                 ndr->depth++;
13770                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13771                 ndr->depth--;
13772                 ndr_print_int32(ndr, "level", r->in.level);
13773                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13774                 ndr_print_drsuapi_DsReplicaAddRequest(ndr, "req", &r->in.req);
13775                 ndr->depth--;
13776         }
13777         if (flags & NDR_OUT) {
13778                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaAdd");
13779                 ndr->depth++;
13780                 ndr_print_WERROR(ndr, "result", r->out.result);
13781                 ndr->depth--;
13782         }
13783         ndr->depth--;
13784 }
13785
13786 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDel(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaDel *r)
13787 {
13788         if (flags & NDR_IN) {
13789                 if (r->in.bind_handle == NULL) {
13790                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13791                 }
13792                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13793                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13794                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13795                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13796         }
13797         if (flags & NDR_OUT) {
13798                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13799         }
13800         return NDR_ERR_SUCCESS;
13801 }
13802
13803 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDel(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaDel *r)
13804 {
13805         TALLOC_CTX *_mem_save_bind_handle_0;
13806         if (flags & NDR_IN) {
13807                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13808                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13809                 }
13810                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13811                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13812                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13813                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13814                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13815                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13816                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13817         }
13818         if (flags & NDR_OUT) {
13819                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13820         }
13821         return NDR_ERR_SUCCESS;
13822 }
13823
13824 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r)
13825 {
13826         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDel");
13827         ndr->depth++;
13828         if (flags & NDR_SET_VALUES) {
13829                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13830         }
13831         if (flags & NDR_IN) {
13832                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaDel");
13833                 ndr->depth++;
13834                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13835                 ndr->depth++;
13836                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13837                 ndr->depth--;
13838                 ndr_print_int32(ndr, "level", r->in.level);
13839                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13840                 ndr_print_drsuapi_DsReplicaDelRequest(ndr, "req", &r->in.req);
13841                 ndr->depth--;
13842         }
13843         if (flags & NDR_OUT) {
13844                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaDel");
13845                 ndr->depth++;
13846                 ndr_print_WERROR(ndr, "result", r->out.result);
13847                 ndr->depth--;
13848         }
13849         ndr->depth--;
13850 }
13851
13852 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMod(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaMod *r)
13853 {
13854         if (flags & NDR_IN) {
13855                 if (r->in.bind_handle == NULL) {
13856                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13857                 }
13858                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13859                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13860                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13861                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13862         }
13863         if (flags & NDR_OUT) {
13864                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13865         }
13866         return NDR_ERR_SUCCESS;
13867 }
13868
13869 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMod(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaMod *r)
13870 {
13871         TALLOC_CTX *_mem_save_bind_handle_0;
13872         if (flags & NDR_IN) {
13873                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13874                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13875                 }
13876                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13877                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13878                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13879                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13880                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13881                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13882                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13883         }
13884         if (flags & NDR_OUT) {
13885                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13886         }
13887         return NDR_ERR_SUCCESS;
13888 }
13889
13890 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r)
13891 {
13892         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMod");
13893         ndr->depth++;
13894         if (flags & NDR_SET_VALUES) {
13895                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13896         }
13897         if (flags & NDR_IN) {
13898                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaMod");
13899                 ndr->depth++;
13900                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13901                 ndr->depth++;
13902                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13903                 ndr->depth--;
13904                 ndr_print_int32(ndr, "level", r->in.level);
13905                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13906                 ndr_print_drsuapi_DsReplicaModRequest(ndr, "req", &r->in.req);
13907                 ndr->depth--;
13908         }
13909         if (flags & NDR_OUT) {
13910                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaMod");
13911                 ndr->depth++;
13912                 ndr_print_WERROR(ndr, "result", r->out.result);
13913                 ndr->depth--;
13914         }
13915         ndr->depth--;
13916 }
13917
13918 static enum ndr_err_code ndr_push_DRSUAPI_VERIFY_NAMES(struct ndr_push *ndr, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13919 {
13920         if (flags & NDR_IN) {
13921         }
13922         if (flags & NDR_OUT) {
13923                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13924         }
13925         return NDR_ERR_SUCCESS;
13926 }
13927
13928 static enum ndr_err_code ndr_pull_DRSUAPI_VERIFY_NAMES(struct ndr_pull *ndr, int flags, struct DRSUAPI_VERIFY_NAMES *r)
13929 {
13930         if (flags & NDR_IN) {
13931         }
13932         if (flags & NDR_OUT) {
13933                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13934         }
13935         return NDR_ERR_SUCCESS;
13936 }
13937
13938 _PUBLIC_ void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13939 {
13940         ndr_print_struct(ndr, name, "DRSUAPI_VERIFY_NAMES");
13941         ndr->depth++;
13942         if (flags & NDR_SET_VALUES) {
13943                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13944         }
13945         if (flags & NDR_IN) {
13946                 ndr_print_struct(ndr, "in", "DRSUAPI_VERIFY_NAMES");
13947                 ndr->depth++;
13948                 ndr->depth--;
13949         }
13950         if (flags & NDR_OUT) {
13951                 ndr_print_struct(ndr, "out", "DRSUAPI_VERIFY_NAMES");
13952                 ndr->depth++;
13953                 ndr_print_WERROR(ndr, "result", r->out.result);
13954                 ndr->depth--;
13955         }
13956         ndr->depth--;
13957 }
13958
13959 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships *r)
13960 {
13961         if (flags & NDR_IN) {
13962                 if (r->in.bind_handle == NULL) {
13963                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13964                 }
13965                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13966                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13967                 if (r->in.req == NULL) {
13968                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13969                 }
13970                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13971                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13972         }
13973         if (flags & NDR_OUT) {
13974                 if (r->out.level_out == NULL) {
13975                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13976                 }
13977                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13978                 if (r->out.ctr == NULL) {
13979                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13980                 }
13981                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13982                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13983                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13984         }
13985         return NDR_ERR_SUCCESS;
13986 }
13987
13988 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships *r)
13989 {
13990         TALLOC_CTX *_mem_save_bind_handle_0;
13991         TALLOC_CTX *_mem_save_req_0;
13992         TALLOC_CTX *_mem_save_level_out_0;
13993         TALLOC_CTX *_mem_save_ctr_0;
13994         if (flags & NDR_IN) {
13995                 ZERO_STRUCT(r->out);
13996
13997                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13998                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13999                 }
14000                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14001                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14002                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14003                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14004                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14005                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14006                         NDR_PULL_ALLOC(ndr, r->in.req);
14007                 }
14008                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14009                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14010                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14011                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14012                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14013                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14014                 ZERO_STRUCTP(r->out.level_out);
14015                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14016                 ZERO_STRUCTP(r->out.ctr);
14017         }
14018         if (flags & NDR_OUT) {
14019                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14020                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14021                 }
14022                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14023                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14024                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14025                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14026                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14027                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14028                 }
14029                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14030                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14031                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14032                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14033                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14034                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14035         }
14036         return NDR_ERR_SUCCESS;
14037 }
14038
14039 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r)
14040 {
14041         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships");
14042         ndr->depth++;
14043         if (flags & NDR_SET_VALUES) {
14044                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14045         }
14046         if (flags & NDR_IN) {
14047                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships");
14048                 ndr->depth++;
14049                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14050                 ndr->depth++;
14051                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14052                 ndr->depth--;
14053                 ndr_print_int32(ndr, "level", r->in.level);
14054                 ndr_print_ptr(ndr, "req", r->in.req);
14055                 ndr->depth++;
14056                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14057                 ndr_print_drsuapi_DsGetMembershipsRequest(ndr, "req", r->in.req);
14058                 ndr->depth--;
14059                 ndr->depth--;
14060         }
14061         if (flags & NDR_OUT) {
14062                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships");
14063                 ndr->depth++;
14064                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14065                 ndr->depth++;
14066                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14067                 ndr->depth--;
14068                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14069                 ndr->depth++;
14070                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14071                 ndr_print_drsuapi_DsGetMembershipsCtr(ndr, "ctr", r->out.ctr);
14072                 ndr->depth--;
14073                 ndr_print_WERROR(ndr, "result", r->out.result);
14074                 ndr->depth--;
14075         }
14076         ndr->depth--;
14077 }
14078
14079 static enum ndr_err_code ndr_push_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_push *ndr, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14080 {
14081         if (flags & NDR_IN) {
14082         }
14083         if (flags & NDR_OUT) {
14084                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14085         }
14086         return NDR_ERR_SUCCESS;
14087 }
14088
14089 static enum ndr_err_code ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_pull *ndr, int flags, struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14090 {
14091         if (flags & NDR_IN) {
14092         }
14093         if (flags & NDR_OUT) {
14094                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14095         }
14096         return NDR_ERR_SUCCESS;
14097 }
14098
14099 _PUBLIC_ void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14100 {
14101         ndr_print_struct(ndr, name, "DRSUAPI_INTER_DOMAIN_MOVE");
14102         ndr->depth++;
14103         if (flags & NDR_SET_VALUES) {
14104                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14105         }
14106         if (flags & NDR_IN) {
14107                 ndr_print_struct(ndr, "in", "DRSUAPI_INTER_DOMAIN_MOVE");
14108                 ndr->depth++;
14109                 ndr->depth--;
14110         }
14111         if (flags & NDR_OUT) {
14112                 ndr_print_struct(ndr, "out", "DRSUAPI_INTER_DOMAIN_MOVE");
14113                 ndr->depth++;
14114                 ndr_print_WERROR(ndr, "result", r->out.result);
14115                 ndr->depth--;
14116         }
14117         ndr->depth--;
14118 }
14119
14120 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLog(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14121 {
14122         if (flags & NDR_IN) {
14123                 if (r->in.bind_handle == NULL) {
14124                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14125                 }
14126                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14128                 if (r->in.req == NULL) {
14129                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14130                 }
14131                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14132                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14133         }
14134         if (flags & NDR_OUT) {
14135                 if (r->out.level_out == NULL) {
14136                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14137                 }
14138                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14139                 if (r->out.info == NULL) {
14140                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14141                 }
14142                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.level_out));
14143                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14144                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14145         }
14146         return NDR_ERR_SUCCESS;
14147 }
14148
14149 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLog(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNT4ChangeLog *r)
14150 {
14151         TALLOC_CTX *_mem_save_bind_handle_0;
14152         TALLOC_CTX *_mem_save_req_0;
14153         TALLOC_CTX *_mem_save_level_out_0;
14154         TALLOC_CTX *_mem_save_info_0;
14155         if (flags & NDR_IN) {
14156                 ZERO_STRUCT(r->out);
14157
14158                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14159                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14160                 }
14161                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14162                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14163                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14164                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14166                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14167                         NDR_PULL_ALLOC(ndr, r->in.req);
14168                 }
14169                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14170                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14171                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14172                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14173                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14174                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14175                 ZERO_STRUCTP(r->out.level_out);
14176                 NDR_PULL_ALLOC(ndr, r->out.info);
14177                 ZERO_STRUCTP(r->out.info);
14178         }
14179         if (flags & NDR_OUT) {
14180                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14181                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14182                 }
14183                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14184                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14185                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14186                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14187                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14188                         NDR_PULL_ALLOC(ndr, r->out.info);
14189                 }
14190                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14191                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14192                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.level_out));
14193                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14194                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14195                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14196         }
14197         return NDR_ERR_SUCCESS;
14198 }
14199
14200 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLog(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14201 {
14202         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLog");
14203         ndr->depth++;
14204         if (flags & NDR_SET_VALUES) {
14205                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14206         }
14207         if (flags & NDR_IN) {
14208                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNT4ChangeLog");
14209                 ndr->depth++;
14210                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14211                 ndr->depth++;
14212                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14213                 ndr->depth--;
14214                 ndr_print_uint32(ndr, "level", r->in.level);
14215                 ndr_print_ptr(ndr, "req", r->in.req);
14216                 ndr->depth++;
14217                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14218                 ndr_print_drsuapi_DsGetNT4ChangeLogRequest(ndr, "req", r->in.req);
14219                 ndr->depth--;
14220                 ndr->depth--;
14221         }
14222         if (flags & NDR_OUT) {
14223                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNT4ChangeLog");
14224                 ndr->depth++;
14225                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14226                 ndr->depth++;
14227                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14228                 ndr->depth--;
14229                 ndr_print_ptr(ndr, "info", r->out.info);
14230                 ndr->depth++;
14231                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.level_out);
14232                 ndr_print_drsuapi_DsGetNT4ChangeLogInfo(ndr, "info", r->out.info);
14233                 ndr->depth--;
14234                 ndr_print_WERROR(ndr, "result", r->out.result);
14235                 ndr->depth--;
14236         }
14237         ndr->depth--;
14238 }
14239
14240 static enum ndr_err_code ndr_push_drsuapi_DsCrackNames(struct ndr_push *ndr, int flags, const struct drsuapi_DsCrackNames *r)
14241 {
14242         if (flags & NDR_IN) {
14243                 if (r->in.bind_handle == NULL) {
14244                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14245                 }
14246                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14247                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14248                 if (r->in.req == NULL) {
14249                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14250                 }
14251                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14252                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14253         }
14254         if (flags & NDR_OUT) {
14255                 if (r->out.level_out == NULL) {
14256                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14257                 }
14258                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14259                 if (r->out.ctr == NULL) {
14260                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14261                 }
14262                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14263                 NDR_CHECK(ndr_push_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14264                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14265         }
14266         return NDR_ERR_SUCCESS;
14267 }
14268
14269 static enum ndr_err_code ndr_pull_drsuapi_DsCrackNames(struct ndr_pull *ndr, int flags, struct drsuapi_DsCrackNames *r)
14270 {
14271         TALLOC_CTX *_mem_save_bind_handle_0;
14272         TALLOC_CTX *_mem_save_req_0;
14273         TALLOC_CTX *_mem_save_level_out_0;
14274         TALLOC_CTX *_mem_save_ctr_0;
14275         if (flags & NDR_IN) {
14276                 ZERO_STRUCT(r->out);
14277
14278                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14279                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14280                 }
14281                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14282                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14283                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14284                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14285                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14286                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14287                         NDR_PULL_ALLOC(ndr, r->in.req);
14288                 }
14289                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14290                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14291                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14292                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14293                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14294                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14295                 ZERO_STRUCTP(r->out.level_out);
14296                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14297                 ZERO_STRUCTP(r->out.ctr);
14298         }
14299         if (flags & NDR_OUT) {
14300                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14301                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14302                 }
14303                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14304                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14305                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14306                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14307                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14308                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14309                 }
14310                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14311                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14312                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14313                 NDR_CHECK(ndr_pull_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14314                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14315                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14316         }
14317         return NDR_ERR_SUCCESS;
14318 }
14319
14320 _PUBLIC_ void ndr_print_drsuapi_DsCrackNames(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsCrackNames *r)
14321 {
14322         ndr_print_struct(ndr, name, "drsuapi_DsCrackNames");
14323         ndr->depth++;
14324         if (flags & NDR_SET_VALUES) {
14325                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14326         }
14327         if (flags & NDR_IN) {
14328                 ndr_print_struct(ndr, "in", "drsuapi_DsCrackNames");
14329                 ndr->depth++;
14330                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14331                 ndr->depth++;
14332                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14333                 ndr->depth--;
14334                 ndr_print_int32(ndr, "level", r->in.level);
14335                 ndr_print_ptr(ndr, "req", r->in.req);
14336                 ndr->depth++;
14337                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14338                 ndr_print_drsuapi_DsNameRequest(ndr, "req", r->in.req);
14339                 ndr->depth--;
14340                 ndr->depth--;
14341         }
14342         if (flags & NDR_OUT) {
14343                 ndr_print_struct(ndr, "out", "drsuapi_DsCrackNames");
14344                 ndr->depth++;
14345                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14346                 ndr->depth++;
14347                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14348                 ndr->depth--;
14349                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14350                 ndr->depth++;
14351                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14352                 ndr_print_drsuapi_DsNameCtr(ndr, "ctr", r->out.ctr);
14353                 ndr->depth--;
14354                 ndr_print_WERROR(ndr, "result", r->out.result);
14355                 ndr->depth--;
14356         }
14357         ndr->depth--;
14358 }
14359
14360 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpn(struct ndr_push *ndr, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14361 {
14362         if (flags & NDR_IN) {
14363                 if (r->in.bind_handle == NULL) {
14364                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14365                 }
14366                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14367                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14368                 if (r->in.req == NULL) {
14369                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14370                 }
14371                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14372                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14373         }
14374         if (flags & NDR_OUT) {
14375                 if (r->out.level_out == NULL) {
14376                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14377                 }
14378                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14379                 if (r->out.res == NULL) {
14380                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14381                 }
14382                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14383                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14384                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14385         }
14386         return NDR_ERR_SUCCESS;
14387 }
14388
14389 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpn(struct ndr_pull *ndr, int flags, struct drsuapi_DsWriteAccountSpn *r)
14390 {
14391         TALLOC_CTX *_mem_save_bind_handle_0;
14392         TALLOC_CTX *_mem_save_req_0;
14393         TALLOC_CTX *_mem_save_level_out_0;
14394         TALLOC_CTX *_mem_save_res_0;
14395         if (flags & NDR_IN) {
14396                 ZERO_STRUCT(r->out);
14397
14398                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14399                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14400                 }
14401                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14402                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14403                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14404                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14405                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14406                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14407                         NDR_PULL_ALLOC(ndr, r->in.req);
14408                 }
14409                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14410                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14411                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14412                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14413                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14414                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14415                 ZERO_STRUCTP(r->out.level_out);
14416                 NDR_PULL_ALLOC(ndr, r->out.res);
14417                 ZERO_STRUCTP(r->out.res);
14418         }
14419         if (flags & NDR_OUT) {
14420                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14421                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14422                 }
14423                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14424                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14425                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14426                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14427                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14428                         NDR_PULL_ALLOC(ndr, r->out.res);
14429                 }
14430                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14431                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14432                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14433                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14434                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14435                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14436         }
14437         return NDR_ERR_SUCCESS;
14438 }
14439
14440 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpn(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14441 {
14442         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpn");
14443         ndr->depth++;
14444         if (flags & NDR_SET_VALUES) {
14445                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14446         }
14447         if (flags & NDR_IN) {
14448                 ndr_print_struct(ndr, "in", "drsuapi_DsWriteAccountSpn");
14449                 ndr->depth++;
14450                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14451                 ndr->depth++;
14452                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14453                 ndr->depth--;
14454                 ndr_print_int32(ndr, "level", r->in.level);
14455                 ndr_print_ptr(ndr, "req", r->in.req);
14456                 ndr->depth++;
14457                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14458                 ndr_print_drsuapi_DsWriteAccountSpnRequest(ndr, "req", r->in.req);
14459                 ndr->depth--;
14460                 ndr->depth--;
14461         }
14462         if (flags & NDR_OUT) {
14463                 ndr_print_struct(ndr, "out", "drsuapi_DsWriteAccountSpn");
14464                 ndr->depth++;
14465                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14466                 ndr->depth++;
14467                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14468                 ndr->depth--;
14469                 ndr_print_ptr(ndr, "res", r->out.res);
14470                 ndr->depth++;
14471                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14472                 ndr_print_drsuapi_DsWriteAccountSpnResult(ndr, "res", r->out.res);
14473                 ndr->depth--;
14474                 ndr_print_WERROR(ndr, "result", r->out.result);
14475                 ndr->depth--;
14476         }
14477         ndr->depth--;
14478 }
14479
14480 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServer(struct ndr_push *ndr, int flags, const struct drsuapi_DsRemoveDSServer *r)
14481 {
14482         if (flags & NDR_IN) {
14483                 if (r->in.bind_handle == NULL) {
14484                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14485                 }
14486                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14487                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14488                 if (r->in.req == NULL) {
14489                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14490                 }
14491                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14492                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14493         }
14494         if (flags & NDR_OUT) {
14495                 if (r->out.level_out == NULL) {
14496                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14497                 }
14498                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14499                 if (r->out.res == NULL) {
14500                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14501                 }
14502                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14503                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14504                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14505         }
14506         return NDR_ERR_SUCCESS;
14507 }
14508
14509 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServer(struct ndr_pull *ndr, int flags, struct drsuapi_DsRemoveDSServer *r)
14510 {
14511         TALLOC_CTX *_mem_save_bind_handle_0;
14512         TALLOC_CTX *_mem_save_req_0;
14513         TALLOC_CTX *_mem_save_level_out_0;
14514         TALLOC_CTX *_mem_save_res_0;
14515         if (flags & NDR_IN) {
14516                 ZERO_STRUCT(r->out);
14517
14518                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14519                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14520                 }
14521                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14522                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14523                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14524                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14525                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14526                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14527                         NDR_PULL_ALLOC(ndr, r->in.req);
14528                 }
14529                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14530                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14531                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14532                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14533                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14534                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14535                 ZERO_STRUCTP(r->out.level_out);
14536                 NDR_PULL_ALLOC(ndr, r->out.res);
14537                 ZERO_STRUCTP(r->out.res);
14538         }
14539         if (flags & NDR_OUT) {
14540                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14541                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14542                 }
14543                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14544                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14545                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14546                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14547                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14548                         NDR_PULL_ALLOC(ndr, r->out.res);
14549                 }
14550                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14551                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14552                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14553                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14554                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14555                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14556         }
14557         return NDR_ERR_SUCCESS;
14558 }
14559
14560 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServer(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsRemoveDSServer *r)
14561 {
14562         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServer");
14563         ndr->depth++;
14564         if (flags & NDR_SET_VALUES) {
14565                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14566         }
14567         if (flags & NDR_IN) {
14568                 ndr_print_struct(ndr, "in", "drsuapi_DsRemoveDSServer");
14569                 ndr->depth++;
14570                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14571                 ndr->depth++;
14572                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14573                 ndr->depth--;
14574                 ndr_print_int32(ndr, "level", r->in.level);
14575                 ndr_print_ptr(ndr, "req", r->in.req);
14576                 ndr->depth++;
14577                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14578                 ndr_print_drsuapi_DsRemoveDSServerRequest(ndr, "req", r->in.req);
14579                 ndr->depth--;
14580                 ndr->depth--;
14581         }
14582         if (flags & NDR_OUT) {
14583                 ndr_print_struct(ndr, "out", "drsuapi_DsRemoveDSServer");
14584                 ndr->depth++;
14585                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14586                 ndr->depth++;
14587                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14588                 ndr->depth--;
14589                 ndr_print_ptr(ndr, "res", r->out.res);
14590                 ndr->depth++;
14591                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14592                 ndr_print_drsuapi_DsRemoveDSServerResult(ndr, "res", r->out.res);
14593                 ndr->depth--;
14594                 ndr_print_WERROR(ndr, "result", r->out.result);
14595                 ndr->depth--;
14596         }
14597         ndr->depth--;
14598 }
14599
14600 static enum ndr_err_code ndr_push_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_push *ndr, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14601 {
14602         if (flags & NDR_IN) {
14603         }
14604         if (flags & NDR_OUT) {
14605                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14606         }
14607         return NDR_ERR_SUCCESS;
14608 }
14609
14610 static enum ndr_err_code ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_pull *ndr, int flags, struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14611 {
14612         if (flags & NDR_IN) {
14613         }
14614         if (flags & NDR_OUT) {
14615                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14616         }
14617         return NDR_ERR_SUCCESS;
14618 }
14619
14620 _PUBLIC_ void ndr_print_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14621 {
14622         ndr_print_struct(ndr, name, "DRSUAPI_REMOVE_DS_DOMAIN");
14623         ndr->depth++;
14624         if (flags & NDR_SET_VALUES) {
14625                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14626         }
14627         if (flags & NDR_IN) {
14628                 ndr_print_struct(ndr, "in", "DRSUAPI_REMOVE_DS_DOMAIN");
14629                 ndr->depth++;
14630                 ndr->depth--;
14631         }
14632         if (flags & NDR_OUT) {
14633                 ndr_print_struct(ndr, "out", "DRSUAPI_REMOVE_DS_DOMAIN");
14634                 ndr->depth++;
14635                 ndr_print_WERROR(ndr, "result", r->out.result);
14636                 ndr->depth--;
14637         }
14638         ndr->depth--;
14639 }
14640
14641 static enum ndr_err_code ndr_push_drsuapi_DsGetDomainControllerInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14642 {
14643         if (flags & NDR_IN) {
14644                 if (r->in.bind_handle == NULL) {
14645                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14646                 }
14647                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14648                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14649                 if (r->in.req == NULL) {
14650                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14651                 }
14652                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14653                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14654         }
14655         if (flags & NDR_OUT) {
14656                 if (r->out.level_out == NULL) {
14657                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14658                 }
14659                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14660                 if (r->out.ctr == NULL) {
14661                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14662                 }
14663                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14664                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14665                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14666         }
14667         return NDR_ERR_SUCCESS;
14668 }
14669
14670 static enum ndr_err_code ndr_pull_drsuapi_DsGetDomainControllerInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetDomainControllerInfo *r)
14671 {
14672         TALLOC_CTX *_mem_save_bind_handle_0;
14673         TALLOC_CTX *_mem_save_req_0;
14674         TALLOC_CTX *_mem_save_level_out_0;
14675         TALLOC_CTX *_mem_save_ctr_0;
14676         if (flags & NDR_IN) {
14677                 ZERO_STRUCT(r->out);
14678
14679                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14680                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14681                 }
14682                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14683                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14684                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14685                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14686                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14687                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14688                         NDR_PULL_ALLOC(ndr, r->in.req);
14689                 }
14690                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14691                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14692                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14693                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14694                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14695                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14696                 ZERO_STRUCTP(r->out.level_out);
14697                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14698                 ZERO_STRUCTP(r->out.ctr);
14699         }
14700         if (flags & NDR_OUT) {
14701                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14702                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14703                 }
14704                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14705                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14706                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14707                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14708                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14709                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14710                 }
14711                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14712                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14713                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14714                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14715                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14716                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14717         }
14718         return NDR_ERR_SUCCESS;
14719 }
14720
14721 _PUBLIC_ void ndr_print_drsuapi_DsGetDomainControllerInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14722 {
14723         ndr_print_struct(ndr, name, "drsuapi_DsGetDomainControllerInfo");
14724         ndr->depth++;
14725         if (flags & NDR_SET_VALUES) {
14726                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14727         }
14728         if (flags & NDR_IN) {
14729                 ndr_print_struct(ndr, "in", "drsuapi_DsGetDomainControllerInfo");
14730                 ndr->depth++;
14731                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14732                 ndr->depth++;
14733                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14734                 ndr->depth--;
14735                 ndr_print_int32(ndr, "level", r->in.level);
14736                 ndr_print_ptr(ndr, "req", r->in.req);
14737                 ndr->depth++;
14738                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14739                 ndr_print_drsuapi_DsGetDCInfoRequest(ndr, "req", r->in.req);
14740                 ndr->depth--;
14741                 ndr->depth--;
14742         }
14743         if (flags & NDR_OUT) {
14744                 ndr_print_struct(ndr, "out", "drsuapi_DsGetDomainControllerInfo");
14745                 ndr->depth++;
14746                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14747                 ndr->depth++;
14748                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14749                 ndr->depth--;
14750                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14751                 ndr->depth++;
14752                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14753                 ndr_print_drsuapi_DsGetDCInfoCtr(ndr, "ctr", r->out.ctr);
14754                 ndr->depth--;
14755                 ndr_print_WERROR(ndr, "result", r->out.result);
14756                 ndr->depth--;
14757         }
14758         ndr->depth--;
14759 }
14760
14761 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAddEntry(struct ndr_push *ndr, int flags, const struct drsuapi_DsAddEntry *r)
14762 {
14763         if (flags & NDR_IN) {
14764                 if (r->in.bind_handle == NULL) {
14765                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14766                 }
14767                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14768                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14769                 if (r->in.req == NULL) {
14770                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14771                 }
14772                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14773                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14774         }
14775         if (flags & NDR_OUT) {
14776                 if (r->out.level_out == NULL) {
14777                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14778                 }
14779                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14780                 if (r->out.ctr == NULL) {
14781                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14782                 }
14783                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14784                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14785                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14786         }
14787         return NDR_ERR_SUCCESS;
14788 }
14789
14790 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAddEntry(struct ndr_pull *ndr, int flags, struct drsuapi_DsAddEntry *r)
14791 {
14792         TALLOC_CTX *_mem_save_bind_handle_0;
14793         TALLOC_CTX *_mem_save_req_0;
14794         TALLOC_CTX *_mem_save_level_out_0;
14795         TALLOC_CTX *_mem_save_ctr_0;
14796         if (flags & NDR_IN) {
14797                 ZERO_STRUCT(r->out);
14798
14799                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14800                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14801                 }
14802                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14803                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14804                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14805                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14806                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14807                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14808                         NDR_PULL_ALLOC(ndr, r->in.req);
14809                 }
14810                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14811                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14812                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14813                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14814                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14815                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14816                 ZERO_STRUCTP(r->out.level_out);
14817                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14818                 ZERO_STRUCTP(r->out.ctr);
14819         }
14820         if (flags & NDR_OUT) {
14821                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14822                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14823                 }
14824                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14825                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14826                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14827                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14828                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14829                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14830                 }
14831                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14832                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14833                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14834                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14835                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14836                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14837         }
14838         return NDR_ERR_SUCCESS;
14839 }
14840
14841 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsAddEntry *r)
14842 {
14843         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry");
14844         ndr->depth++;
14845         if (flags & NDR_SET_VALUES) {
14846                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14847         }
14848         if (flags & NDR_IN) {
14849                 ndr_print_struct(ndr, "in", "drsuapi_DsAddEntry");
14850                 ndr->depth++;
14851                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14852                 ndr->depth++;
14853                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14854                 ndr->depth--;
14855                 ndr_print_int32(ndr, "level", r->in.level);
14856                 ndr_print_ptr(ndr, "req", r->in.req);
14857                 ndr->depth++;
14858                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14859                 ndr_print_drsuapi_DsAddEntryRequest(ndr, "req", r->in.req);
14860                 ndr->depth--;
14861                 ndr->depth--;
14862         }
14863         if (flags & NDR_OUT) {
14864                 ndr_print_struct(ndr, "out", "drsuapi_DsAddEntry");
14865                 ndr->depth++;
14866                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14867                 ndr->depth++;
14868                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14869                 ndr->depth--;
14870                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14871                 ndr->depth++;
14872                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14873                 ndr_print_drsuapi_DsAddEntryCtr(ndr, "ctr", r->out.ctr);
14874                 ndr->depth--;
14875                 ndr_print_WERROR(ndr, "result", r->out.result);
14876                 ndr->depth--;
14877         }
14878         ndr->depth--;
14879 }
14880
14881 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC(struct ndr_push *ndr, int flags, const struct drsuapi_DsExecuteKCC *r)
14882 {
14883         if (flags & NDR_IN) {
14884                 if (r->in.bind_handle == NULL) {
14885                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14886                 }
14887                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14888                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14889                 if (r->in.req == NULL) {
14890                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14891                 }
14892                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14893                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14894         }
14895         if (flags & NDR_OUT) {
14896                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14897         }
14898         return NDR_ERR_SUCCESS;
14899 }
14900
14901 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC(struct ndr_pull *ndr, int flags, struct drsuapi_DsExecuteKCC *r)
14902 {
14903         TALLOC_CTX *_mem_save_bind_handle_0;
14904         TALLOC_CTX *_mem_save_req_0;
14905         if (flags & NDR_IN) {
14906                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14907                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14908                 }
14909                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14910                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14911                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14912                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14914                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14915                         NDR_PULL_ALLOC(ndr, r->in.req);
14916                 }
14917                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14918                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14919                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14920                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14921                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14922         }
14923         if (flags & NDR_OUT) {
14924                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14925         }
14926         return NDR_ERR_SUCCESS;
14927 }
14928
14929 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsExecuteKCC *r)
14930 {
14931         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC");
14932         ndr->depth++;
14933         if (flags & NDR_SET_VALUES) {
14934                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14935         }
14936         if (flags & NDR_IN) {
14937                 ndr_print_struct(ndr, "in", "drsuapi_DsExecuteKCC");
14938                 ndr->depth++;
14939                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14940                 ndr->depth++;
14941                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14942                 ndr->depth--;
14943                 ndr_print_uint32(ndr, "level", r->in.level);
14944                 ndr_print_ptr(ndr, "req", r->in.req);
14945                 ndr->depth++;
14946                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14947                 ndr_print_drsuapi_DsExecuteKCCRequest(ndr, "req", r->in.req);
14948                 ndr->depth--;
14949                 ndr->depth--;
14950         }
14951         if (flags & NDR_OUT) {
14952                 ndr_print_struct(ndr, "out", "drsuapi_DsExecuteKCC");
14953                 ndr->depth++;
14954                 ndr_print_WERROR(ndr, "result", r->out.result);
14955                 ndr->depth--;
14956         }
14957         ndr->depth--;
14958 }
14959
14960 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaGetInfo *r)
14961 {
14962         if (flags & NDR_IN) {
14963                 if (r->in.bind_handle == NULL) {
14964                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14965                 }
14966                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14967                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, r->in.level));
14968                 if (r->in.req == NULL) {
14969                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14970                 }
14971                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14972                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14973         }
14974         if (flags & NDR_OUT) {
14975                 if (r->out.info_type == NULL) {
14976                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14977                 }
14978                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, *r->out.info_type));
14979                 if (r->out.info == NULL) {
14980                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14981                 }
14982                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.info_type));
14983                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14984                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14985         }
14986         return NDR_ERR_SUCCESS;
14987 }
14988
14989 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaGetInfo *r)
14990 {
14991         TALLOC_CTX *_mem_save_bind_handle_0;
14992         TALLOC_CTX *_mem_save_req_0;
14993         TALLOC_CTX *_mem_save_info_type_0;
14994         TALLOC_CTX *_mem_save_info_0;
14995         if (flags & NDR_IN) {
14996                 ZERO_STRUCT(r->out);
14997
14998                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14999                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15000                 }
15001                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15002                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15003                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15004                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15005                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, &r->in.level));
15006                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15007                         NDR_PULL_ALLOC(ndr, r->in.req);
15008                 }
15009                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15010                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15011                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15012                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15013                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15014                 NDR_PULL_ALLOC(ndr, r->out.info_type);
15015                 ZERO_STRUCTP(r->out.info_type);
15016                 NDR_PULL_ALLOC(ndr, r->out.info);
15017                 ZERO_STRUCTP(r->out.info);
15018         }
15019         if (flags & NDR_OUT) {
15020                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15021                         NDR_PULL_ALLOC(ndr, r->out.info_type);
15022                 }
15023                 _mem_save_info_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
15024                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_type, LIBNDR_FLAG_REF_ALLOC);
15025                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->out.info_type));
15026                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_type_0, LIBNDR_FLAG_REF_ALLOC);
15027                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15028                         NDR_PULL_ALLOC(ndr, r->out.info);
15029                 }
15030                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15031                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
15032                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.info_type));
15033                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15034                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15035                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15036         }
15037         return NDR_ERR_SUCCESS;
15038 }
15039
15040 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaGetInfo *r)
15041 {
15042         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfo");
15043         ndr->depth++;
15044         if (flags & NDR_SET_VALUES) {
15045                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15046         }
15047         if (flags & NDR_IN) {
15048                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaGetInfo");
15049                 ndr->depth++;
15050                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15051                 ndr->depth++;
15052                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15053                 ndr->depth--;
15054                 ndr_print_drsuapi_DsReplicaGetInfoLevel(ndr, "level", r->in.level);
15055                 ndr_print_ptr(ndr, "req", r->in.req);
15056                 ndr->depth++;
15057                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15058                 ndr_print_drsuapi_DsReplicaGetInfoRequest(ndr, "req", r->in.req);
15059                 ndr->depth--;
15060                 ndr->depth--;
15061         }
15062         if (flags & NDR_OUT) {
15063                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaGetInfo");
15064                 ndr->depth++;
15065                 ndr_print_ptr(ndr, "info_type", r->out.info_type);
15066                 ndr->depth++;
15067                 ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", *r->out.info_type);
15068                 ndr->depth--;
15069                 ndr_print_ptr(ndr, "info", r->out.info);
15070                 ndr->depth++;
15071                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.info_type);
15072                 ndr_print_drsuapi_DsReplicaInfo(ndr, "info", r->out.info);
15073                 ndr->depth--;
15074                 ndr_print_WERROR(ndr, "result", r->out.result);
15075                 ndr->depth--;
15076         }
15077         ndr->depth--;
15078 }
15079
15080 static enum ndr_err_code ndr_push_DRSUAPI_ADD_SID_HISTORY(struct ndr_push *ndr, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15081 {
15082         if (flags & NDR_IN) {
15083         }
15084         if (flags & NDR_OUT) {
15085                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15086         }
15087         return NDR_ERR_SUCCESS;
15088 }
15089
15090 static enum ndr_err_code ndr_pull_DRSUAPI_ADD_SID_HISTORY(struct ndr_pull *ndr, int flags, struct DRSUAPI_ADD_SID_HISTORY *r)
15091 {
15092         if (flags & NDR_IN) {
15093         }
15094         if (flags & NDR_OUT) {
15095                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15096         }
15097         return NDR_ERR_SUCCESS;
15098 }
15099
15100 _PUBLIC_ void ndr_print_DRSUAPI_ADD_SID_HISTORY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15101 {
15102         ndr_print_struct(ndr, name, "DRSUAPI_ADD_SID_HISTORY");
15103         ndr->depth++;
15104         if (flags & NDR_SET_VALUES) {
15105                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15106         }
15107         if (flags & NDR_IN) {
15108                 ndr_print_struct(ndr, "in", "DRSUAPI_ADD_SID_HISTORY");
15109                 ndr->depth++;
15110                 ndr->depth--;
15111         }
15112         if (flags & NDR_OUT) {
15113                 ndr_print_struct(ndr, "out", "DRSUAPI_ADD_SID_HISTORY");
15114                 ndr->depth++;
15115                 ndr_print_WERROR(ndr, "result", r->out.result);
15116                 ndr->depth--;
15117         }
15118         ndr->depth--;
15119 }
15120
15121 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships2 *r)
15122 {
15123         if (flags & NDR_IN) {
15124                 if (r->in.bind_handle == NULL) {
15125                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15126                 }
15127                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15128                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15129                 if (r->in.req == NULL) {
15130                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15131                 }
15132                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15133                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15134         }
15135         if (flags & NDR_OUT) {
15136                 if (r->out.level_out == NULL) {
15137                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15138                 }
15139                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15140                 if (r->out.ctr == NULL) {
15141                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15142                 }
15143                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15144                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15145                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15146         }
15147         return NDR_ERR_SUCCESS;
15148 }
15149
15150 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships2 *r)
15151 {
15152         TALLOC_CTX *_mem_save_bind_handle_0;
15153         TALLOC_CTX *_mem_save_req_0;
15154         TALLOC_CTX *_mem_save_level_out_0;
15155         TALLOC_CTX *_mem_save_ctr_0;
15156         if (flags & NDR_IN) {
15157                 ZERO_STRUCT(r->out);
15158
15159                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15160                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15161                 }
15162                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15163                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15164                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15165                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15166                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15167                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15168                         NDR_PULL_ALLOC(ndr, r->in.req);
15169                 }
15170                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15171                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15172                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15173                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15174                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15175                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15176                 ZERO_STRUCTP(r->out.level_out);
15177                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15178                 ZERO_STRUCTP(r->out.ctr);
15179         }
15180         if (flags & NDR_OUT) {
15181                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15182                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15183                 }
15184                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15185                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15186                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15187                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15188                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15189                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15190                 }
15191                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15192                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15193                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15194                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15195                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15196                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15197         }
15198         return NDR_ERR_SUCCESS;
15199 }
15200
15201 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships2 *r)
15202 {
15203         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2");
15204         ndr->depth++;
15205         if (flags & NDR_SET_VALUES) {
15206                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15207         }
15208         if (flags & NDR_IN) {
15209                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships2");
15210                 ndr->depth++;
15211                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15212                 ndr->depth++;
15213                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15214                 ndr->depth--;
15215                 ndr_print_int32(ndr, "level", r->in.level);
15216                 ndr_print_ptr(ndr, "req", r->in.req);
15217                 ndr->depth++;
15218                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15219                 ndr_print_drsuapi_DsGetMemberships2Request(ndr, "req", r->in.req);
15220                 ndr->depth--;
15221                 ndr->depth--;
15222         }
15223         if (flags & NDR_OUT) {
15224                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships2");
15225                 ndr->depth++;
15226                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15227                 ndr->depth++;
15228                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15229                 ndr->depth--;
15230                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15231                 ndr->depth++;
15232                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15233                 ndr_print_drsuapi_DsGetMemberships2Ctr(ndr, "ctr", r->out.ctr);
15234                 ndr->depth--;
15235                 ndr_print_WERROR(ndr, "result", r->out.result);
15236                 ndr->depth--;
15237         }
15238         ndr->depth--;
15239 }
15240
15241 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15242 {
15243         if (flags & NDR_IN) {
15244         }
15245         if (flags & NDR_OUT) {
15246                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15247         }
15248         return NDR_ERR_SUCCESS;
15249 }
15250
15251 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15252 {
15253         if (flags & NDR_IN) {
15254         }
15255         if (flags & NDR_OUT) {
15256                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15257         }
15258         return NDR_ERR_SUCCESS;
15259 }
15260
15261 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15262 {
15263         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15264         ndr->depth++;
15265         if (flags & NDR_SET_VALUES) {
15266                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15267         }
15268         if (flags & NDR_IN) {
15269                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15270                 ndr->depth++;
15271                 ndr->depth--;
15272         }
15273         if (flags & NDR_OUT) {
15274                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15275                 ndr->depth++;
15276                 ndr_print_WERROR(ndr, "result", r->out.result);
15277                 ndr->depth--;
15278         }
15279         ndr->depth--;
15280 }
15281
15282 static enum ndr_err_code ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_push *ndr, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15283 {
15284         if (flags & NDR_IN) {
15285         }
15286         if (flags & NDR_OUT) {
15287                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15288         }
15289         return NDR_ERR_SUCCESS;
15290 }
15291
15292 static enum ndr_err_code ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_pull *ndr, int flags, struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15293 {
15294         if (flags & NDR_IN) {
15295         }
15296         if (flags & NDR_OUT) {
15297                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15298         }
15299         return NDR_ERR_SUCCESS;
15300 }
15301
15302 _PUBLIC_ void ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15303 {
15304         ndr_print_struct(ndr, name, "DRSUAPI_GET_OBJECT_EXISTENCE");
15305         ndr->depth++;
15306         if (flags & NDR_SET_VALUES) {
15307                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15308         }
15309         if (flags & NDR_IN) {
15310                 ndr_print_struct(ndr, "in", "DRSUAPI_GET_OBJECT_EXISTENCE");
15311                 ndr->depth++;
15312                 ndr->depth--;
15313         }
15314         if (flags & NDR_OUT) {
15315                 ndr_print_struct(ndr, "out", "DRSUAPI_GET_OBJECT_EXISTENCE");
15316                 ndr->depth++;
15317                 ndr_print_WERROR(ndr, "result", r->out.result);
15318                 ndr->depth--;
15319         }
15320         ndr->depth--;
15321 }
15322
15323 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCost(struct ndr_push *ndr, int flags, const struct drsuapi_QuerySitesByCost *r)
15324 {
15325         if (flags & NDR_IN) {
15326                 if (r->in.bind_handle == NULL) {
15327                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15328                 }
15329                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15330                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15331                 if (r->in.req == NULL) {
15332                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15333                 }
15334                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15335                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15336         }
15337         if (flags & NDR_OUT) {
15338                 if (r->out.level_out == NULL) {
15339                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15340                 }
15341                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15342                 if (r->out.ctr == NULL) {
15343                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15344                 }
15345                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15346                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15347                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15348         }
15349         return NDR_ERR_SUCCESS;
15350 }
15351
15352 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCost(struct ndr_pull *ndr, int flags, struct drsuapi_QuerySitesByCost *r)
15353 {
15354         TALLOC_CTX *_mem_save_bind_handle_0;
15355         TALLOC_CTX *_mem_save_req_0;
15356         TALLOC_CTX *_mem_save_level_out_0;
15357         TALLOC_CTX *_mem_save_ctr_0;
15358         if (flags & NDR_IN) {
15359                 ZERO_STRUCT(r->out);
15360
15361                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15362                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15363                 }
15364                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15365                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15366                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15367                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15368                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15369                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15370                         NDR_PULL_ALLOC(ndr, r->in.req);
15371                 }
15372                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15373                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15374                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15375                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15376                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15377                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15378                 ZERO_STRUCTP(r->out.level_out);
15379                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15380                 ZERO_STRUCTP(r->out.ctr);
15381         }
15382         if (flags & NDR_OUT) {
15383                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15384                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15385                 }
15386                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15387                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15388                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15389                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15390                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15391                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15392                 }
15393                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15394                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15395                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15396                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15397                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15398                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15399         }
15400         return NDR_ERR_SUCCESS;
15401 }
15402
15403 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCost(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_QuerySitesByCost *r)
15404 {
15405         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCost");
15406         ndr->depth++;
15407         if (flags & NDR_SET_VALUES) {
15408                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15409         }
15410         if (flags & NDR_IN) {
15411                 ndr_print_struct(ndr, "in", "drsuapi_QuerySitesByCost");
15412                 ndr->depth++;
15413                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15414                 ndr->depth++;
15415                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15416                 ndr->depth--;
15417                 ndr_print_int32(ndr, "level", r->in.level);
15418                 ndr_print_ptr(ndr, "req", r->in.req);
15419                 ndr->depth++;
15420                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15421                 ndr_print_drsuapi_QuerySitesByCostRequest(ndr, "req", r->in.req);
15422                 ndr->depth--;
15423                 ndr->depth--;
15424         }
15425         if (flags & NDR_OUT) {
15426                 ndr_print_struct(ndr, "out", "drsuapi_QuerySitesByCost");
15427                 ndr->depth++;
15428                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15429                 ndr->depth++;
15430                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15431                 ndr->depth--;
15432                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15433                 ndr->depth++;
15434                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15435                 ndr_print_drsuapi_QuerySitesByCostCtr(ndr, "ctr", r->out.ctr);
15436                 ndr->depth--;
15437                 ndr_print_WERROR(ndr, "result", r->out.result);
15438                 ndr->depth--;
15439         }
15440         ndr->depth--;
15441 }
15442
15443 static const struct ndr_interface_call drsuapi_calls[] = {
15444         {
15445                 "drsuapi_DsBind",
15446                 sizeof(struct drsuapi_DsBind),
15447                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsBind,
15448                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsBind,
15449                 (ndr_print_function_t) ndr_print_drsuapi_DsBind,
15450                 false,
15451         },
15452         {
15453                 "drsuapi_DsUnbind",
15454                 sizeof(struct drsuapi_DsUnbind),
15455                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsUnbind,
15456                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsUnbind,
15457                 (ndr_print_function_t) ndr_print_drsuapi_DsUnbind,
15458                 false,
15459         },
15460         {
15461                 "drsuapi_DsReplicaSync",
15462                 sizeof(struct drsuapi_DsReplicaSync),
15463                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaSync,
15464                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaSync,
15465                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaSync,
15466                 false,
15467         },
15468         {
15469                 "drsuapi_DsGetNCChanges",
15470                 sizeof(struct drsuapi_DsGetNCChanges),
15471                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNCChanges,
15472                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNCChanges,
15473                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNCChanges,
15474                 false,
15475         },
15476         {
15477                 "drsuapi_DsReplicaUpdateRefs",
15478                 sizeof(struct drsuapi_DsReplicaUpdateRefs),
15479                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaUpdateRefs,
15480                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaUpdateRefs,
15481                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaUpdateRefs,
15482                 false,
15483         },
15484         {
15485                 "drsuapi_DsReplicaAdd",
15486                 sizeof(struct drsuapi_DsReplicaAdd),
15487                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaAdd,
15488                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaAdd,
15489                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaAdd,
15490                 false,
15491         },
15492         {
15493                 "drsuapi_DsReplicaDel",
15494                 sizeof(struct drsuapi_DsReplicaDel),
15495                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaDel,
15496                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaDel,
15497                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaDel,
15498                 false,
15499         },
15500         {
15501                 "drsuapi_DsReplicaMod",
15502                 sizeof(struct drsuapi_DsReplicaMod),
15503                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaMod,
15504                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaMod,
15505                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaMod,
15506                 false,
15507         },
15508         {
15509                 "DRSUAPI_VERIFY_NAMES",
15510                 sizeof(struct DRSUAPI_VERIFY_NAMES),
15511                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_VERIFY_NAMES,
15512                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_VERIFY_NAMES,
15513                 (ndr_print_function_t) ndr_print_DRSUAPI_VERIFY_NAMES,
15514                 false,
15515         },
15516         {
15517                 "drsuapi_DsGetMemberships",
15518                 sizeof(struct drsuapi_DsGetMemberships),
15519                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships,
15520                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships,
15521                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships,
15522                 false,
15523         },
15524         {
15525                 "DRSUAPI_INTER_DOMAIN_MOVE",
15526                 sizeof(struct DRSUAPI_INTER_DOMAIN_MOVE),
15527                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_INTER_DOMAIN_MOVE,
15528                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE,
15529                 (ndr_print_function_t) ndr_print_DRSUAPI_INTER_DOMAIN_MOVE,
15530                 false,
15531         },
15532         {
15533                 "drsuapi_DsGetNT4ChangeLog",
15534                 sizeof(struct drsuapi_DsGetNT4ChangeLog),
15535                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNT4ChangeLog,
15536                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNT4ChangeLog,
15537                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNT4ChangeLog,
15538                 false,
15539         },
15540         {
15541                 "drsuapi_DsCrackNames",
15542                 sizeof(struct drsuapi_DsCrackNames),
15543                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsCrackNames,
15544                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsCrackNames,
15545                 (ndr_print_function_t) ndr_print_drsuapi_DsCrackNames,
15546                 false,
15547         },
15548         {
15549                 "drsuapi_DsWriteAccountSpn",
15550                 sizeof(struct drsuapi_DsWriteAccountSpn),
15551                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsWriteAccountSpn,
15552                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsWriteAccountSpn,
15553                 (ndr_print_function_t) ndr_print_drsuapi_DsWriteAccountSpn,
15554                 false,
15555         },
15556         {
15557                 "drsuapi_DsRemoveDSServer",
15558                 sizeof(struct drsuapi_DsRemoveDSServer),
15559                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsRemoveDSServer,
15560                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsRemoveDSServer,
15561                 (ndr_print_function_t) ndr_print_drsuapi_DsRemoveDSServer,
15562                 false,
15563         },
15564         {
15565                 "DRSUAPI_REMOVE_DS_DOMAIN",
15566                 sizeof(struct DRSUAPI_REMOVE_DS_DOMAIN),
15567                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REMOVE_DS_DOMAIN,
15568                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN,
15569                 (ndr_print_function_t) ndr_print_DRSUAPI_REMOVE_DS_DOMAIN,
15570                 false,
15571         },
15572         {
15573                 "drsuapi_DsGetDomainControllerInfo",
15574                 sizeof(struct drsuapi_DsGetDomainControllerInfo),
15575                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetDomainControllerInfo,
15576                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetDomainControllerInfo,
15577                 (ndr_print_function_t) ndr_print_drsuapi_DsGetDomainControllerInfo,
15578                 false,
15579         },
15580         {
15581                 "drsuapi_DsAddEntry",
15582                 sizeof(struct drsuapi_DsAddEntry),
15583                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsAddEntry,
15584                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsAddEntry,
15585                 (ndr_print_function_t) ndr_print_drsuapi_DsAddEntry,
15586                 false,
15587         },
15588         {
15589                 "drsuapi_DsExecuteKCC",
15590                 sizeof(struct drsuapi_DsExecuteKCC),
15591                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsExecuteKCC,
15592                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsExecuteKCC,
15593                 (ndr_print_function_t) ndr_print_drsuapi_DsExecuteKCC,
15594                 false,
15595         },
15596         {
15597                 "drsuapi_DsReplicaGetInfo",
15598                 sizeof(struct drsuapi_DsReplicaGetInfo),
15599                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaGetInfo,
15600                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaGetInfo,
15601                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaGetInfo,
15602                 false,
15603         },
15604         {
15605                 "DRSUAPI_ADD_SID_HISTORY",
15606                 sizeof(struct DRSUAPI_ADD_SID_HISTORY),
15607                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_ADD_SID_HISTORY,
15608                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_ADD_SID_HISTORY,
15609                 (ndr_print_function_t) ndr_print_DRSUAPI_ADD_SID_HISTORY,
15610                 false,
15611         },
15612         {
15613                 "drsuapi_DsGetMemberships2",
15614                 sizeof(struct drsuapi_DsGetMemberships2),
15615                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships2,
15616                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships2,
15617                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships2,
15618                 false,
15619         },
15620         {
15621                 "DRSUAPI_REPLICA_VERIFY_OBJECTS",
15622                 sizeof(struct DRSUAPI_REPLICA_VERIFY_OBJECTS),
15623                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15624                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15625                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15626                 false,
15627         },
15628         {
15629                 "DRSUAPI_GET_OBJECT_EXISTENCE",
15630                 sizeof(struct DRSUAPI_GET_OBJECT_EXISTENCE),
15631                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE,
15632                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE,
15633                 (ndr_print_function_t) ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE,
15634                 false,
15635         },
15636         {
15637                 "drsuapi_QuerySitesByCost",
15638                 sizeof(struct drsuapi_QuerySitesByCost),
15639                 (ndr_push_flags_fn_t) ndr_push_drsuapi_QuerySitesByCost,
15640                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_QuerySitesByCost,
15641                 (ndr_print_function_t) ndr_print_drsuapi_QuerySitesByCost,
15642                 false,
15643         },
15644         { NULL, 0, NULL, NULL, NULL, false }
15645 };
15646
15647 static const char * const drsuapi_endpoint_strings[] = {
15648         "ncacn_np:[\\pipe\\lsass]",
15649         "ncacn_np:[\\pipe\\protected_storage]",
15650         "ncacn_ip_tcp:",
15651         "ncalrpc:",
15652 };
15653
15654 static const struct ndr_interface_string_array drsuapi_endpoints = {
15655         .count  = 4,
15656         .names  = drsuapi_endpoint_strings
15657 };
15658
15659 static const char * const drsuapi_authservice_strings[] = {
15660         "ldap",
15661 };
15662
15663 static const struct ndr_interface_string_array drsuapi_authservices = {
15664         .count  = 1,
15665         .names  = drsuapi_authservice_strings
15666 };
15667
15668
15669 const struct ndr_interface_table ndr_table_drsuapi = {
15670         .name           = "drsuapi",
15671         .syntax_id      = {
15672                 {0xe3514235,0x4b06,0x11d1,{0xab,0x04},{0x00,0xc0,0x4f,0xc2,0xdc,0xd2}},
15673                 NDR_DRSUAPI_VERSION
15674         },
15675         .helpstring     = NDR_DRSUAPI_HELPSTRING,
15676         .num_calls      = 25,
15677         .calls          = drsuapi_calls,
15678         .endpoints      = &drsuapi_endpoints,
15679         .authservices   = &drsuapi_authservices
15680 };
15681