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_ADD_REF", DRSUAPI_DRS_ADD_REF, r);
  31         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_ALL", DRSUAPI_DRS_SYNC_ALL, r);
  32         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DEL_REF", DRSUAPI_DRS_DEL_REF, r);
  33         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_WRIT_REP", DRSUAPI_DRS_WRIT_REP, r);
  34         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_INIT_SYNC", DRSUAPI_DRS_INIT_SYNC, r);
  35         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_PER_SYNC", DRSUAPI_DRS_PER_SYNC, r);
  36         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_MAIL_REP", DRSUAPI_DRS_MAIL_REP, r);
  37         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_ASYNC_REP", DRSUAPI_DRS_ASYNC_REP, r);
  38         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_IGNORE_ERROR", DRSUAPI_DRS_IGNORE_ERROR, r);
  39         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_TWOWAY_SYNC", DRSUAPI_DRS_TWOWAY_SYNC, r);
  40         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_CRITICAL_ONLY", DRSUAPI_DRS_CRITICAL_ONLY, r);
  41         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_ANC", DRSUAPI_DRS_GET_ANC, r);
  42         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_NC_SIZE", DRSUAPI_DRS_GET_NC_SIZE, r);
  43         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_LOCAL_ONLY", DRSUAPI_DRS_LOCAL_ONLY, r);
  44         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_BYNAME", DRSUAPI_DRS_SYNC_BYNAME, r);
  45         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_REF_OK", DRSUAPI_DRS_REF_OK, r);
  46         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_NOW", DRSUAPI_DRS_FULL_SYNC_NOW, r);
  47         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NO_SOURCE", DRSUAPI_DRS_NO_SOURCE, r);
  48         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_PACKET", DRSUAPI_DRS_FULL_SYNC_PACKET, r);
  49         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_REF_GCSPN", DRSUAPI_DRS_REF_GCSPN, r);
  50         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING", DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING, r);
  51         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_FORCED", DRSUAPI_DRS_SYNC_FORCED, r);
  52         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DISABLE_AUTO_SYNC", DRSUAPI_DRS_DISABLE_AUTO_SYNC, r);
  53         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DISABLE_PERIODIC_SYNC", DRSUAPI_DRS_DISABLE_PERIODIC_SYNC, r);
  54         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_USE_COMPRESSION", DRSUAPI_DRS_USE_COMPRESSION, r);
  55         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NEVER_NOTIFY", DRSUAPI_DRS_NEVER_NOTIFY, r);
  56         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_PAS", DRSUAPI_DRS_SYNC_PAS, r);
  57         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_ALL_GROUP_MEMBERSHIP", DRSUAPI_DRS_GET_ALL_GROUP_MEMBERSHIP, r);
  58         ndr->depth--;
  59 }
  60
  61 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  62 {
  63         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  64         return NDR_ERR_SUCCESS;
  65 }
  66
  67 static enum ndr_err_code ndr_pull_drsuapi_SupportedExtensions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  68 {
  69         uint32_t v;
  70         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  71         *r = v;
  72         return NDR_ERR_SUCCESS;
  73 }
  74
  75 _PUBLIC_ void ndr_print_drsuapi_SupportedExtensions(struct ndr_print *ndr, const char *name, uint32_t r)
  76 {
  77         ndr_print_uint32(ndr, name, r);
  78         ndr->depth++;
  79         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_BASE", DRSUAPI_SUPPORTED_EXTENSION_BASE, r);
  80         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION", DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION, r);
  81         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI", DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI, r);
  82         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2", DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2, r);
  83         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS", DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS, r);
  84         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1, r);
  85         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION", DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION, r);
  86         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_00000080", DRSUAPI_SUPPORTED_EXTENSION_00000080, r);
  87         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE", DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE, r);
  88         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2, r);
  89         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION", DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION, r);
  90         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2, r);
  91         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);
  92         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND", DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND, r);
  93         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO", DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO, r);
  94         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION", DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION, r);
  95         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01, r);
  96         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP", DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP, r);
  97         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY", DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY, r);
  98         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3", DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3, r);
  99         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_00100000", DRSUAPI_SUPPORTED_EXTENSION_00100000, r);
 100         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2", DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2, r);
 101         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6, r);
 102         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS", DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS, r);
 103         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8, r);
 104         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5, r);
 105         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6, r);
 106         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3, r);
 107         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7, r);
 108         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT", DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT, r);
 109         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS", DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS, r);
 110         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_20000000", DRSUAPI_SUPPORTED_EXTENSION_20000000, r);
 111         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_40000000", DRSUAPI_SUPPORTED_EXTENSION_40000000, r);
 112         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_80000000", DRSUAPI_SUPPORTED_EXTENSION_80000000, r);
 113         ndr->depth--;
 114 }
 115
 116 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensionsExt(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 117 {
 118         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 119         return NDR_ERR_SUCCESS;
 120 }
 121
 122 static enum ndr_err_code ndr_pull_drsuapi_SupportedExtensionsExt(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 123 {
 124         uint32_t v;
 125         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 126         *r = v;
 127         return NDR_ERR_SUCCESS;
 128 }
 129
 130 _PUBLIC_ void ndr_print_drsuapi_SupportedExtensionsExt(struct ndr_print *ndr, const char *name, uint32_t r)
 131 {
 132         ndr_print_uint32(ndr, name, r);
 133         ndr->depth++;
 134         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADAM", DRSUAPI_SUPPORTED_EXTENSION_ADAM, r);
 135         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_LH_BETA2", DRSUAPI_SUPPORTED_EXTENSION_LH_BETA2, r);
 136         ndr->depth--;
 137 }
 138
 139 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo24(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo24 *r)
 140 {
 141         if (ndr_flags & NDR_SCALARS) {
 142                 NDR_CHECK(ndr_push_align(ndr, 4));
 143                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 144                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 145                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 146                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 147         }
 148         if (ndr_flags & NDR_BUFFERS) {
 149         }
 150         return NDR_ERR_SUCCESS;
 151 }
 152
 153 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo24(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo24 *r)
 154 {
 155         if (ndr_flags & NDR_SCALARS) {
 156                 NDR_CHECK(ndr_pull_align(ndr, 4));
 157                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 158                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 160                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 161         }
 162         if (ndr_flags & NDR_BUFFERS) {
 163         }
 164         return NDR_ERR_SUCCESS;
 165 }
 166
 167 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo24(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo24 *r)
 168 {
 169         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo24");
 170         ndr->depth++;
 171         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 172         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 173         ndr_print_uint32(ndr, "pid", r->pid);
 174         ndr->depth--;
 175 }
 176
 177 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo28(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo28 *r)
 178 {
 179         if (ndr_flags & NDR_SCALARS) {
 180                 NDR_CHECK(ndr_push_align(ndr, 4));
 181                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 182                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 184                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 185                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 186         }
 187         if (ndr_flags & NDR_BUFFERS) {
 188         }
 189         return NDR_ERR_SUCCESS;
 190 }
 191
 192 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo28(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo28 *r)
 193 {
 194         if (ndr_flags & NDR_SCALARS) {
 195                 NDR_CHECK(ndr_pull_align(ndr, 4));
 196                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 197                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 198                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 199                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 200                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 201         }
 202         if (ndr_flags & NDR_BUFFERS) {
 203         }
 204         return NDR_ERR_SUCCESS;
 205 }
 206
 207 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo28(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo28 *r)
 208 {
 209         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo28");
 210         ndr->depth++;
 211         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 212         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 213         ndr_print_uint32(ndr, "pid", r->pid);
 214         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 215         ndr->depth--;
 216 }
 217
 218 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo48(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo48 *r)
 219 {
 220         if (ndr_flags & NDR_SCALARS) {
 221                 NDR_CHECK(ndr_push_align(ndr, 4));
 222                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 223                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 226                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, r->supported_extensions_ext));
 227                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 228                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 229         }
 230         if (ndr_flags & NDR_BUFFERS) {
 231         }
 232         return NDR_ERR_SUCCESS;
 233 }
 234
 235 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo48(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo48 *r)
 236 {
 237         if (ndr_flags & NDR_SCALARS) {
 238                 NDR_CHECK(ndr_pull_align(ndr, 4));
 239                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 240                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 242                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 243                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, &r->supported_extensions_ext));
 244                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 245                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 246         }
 247         if (ndr_flags & NDR_BUFFERS) {
 248         }
 249         return NDR_ERR_SUCCESS;
 250 }
 251
 252 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo48(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo48 *r)
 253 {
 254         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo48");
 255         ndr->depth++;
 256         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 257         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 258         ndr_print_uint32(ndr, "pid", r->pid);
 259         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 260         ndr_print_drsuapi_SupportedExtensionsExt(ndr, "supported_extensions_ext", r->supported_extensions_ext);
 261         ndr_print_GUID(ndr, "config_dn_guid", &r->config_dn_guid);
 262         ndr->depth--;
 263 }
 264
 265 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoFallBack(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoFallBack *r)
 266 {
 267         if (ndr_flags & NDR_SCALARS) {
 268                 NDR_CHECK(ndr_push_align(ndr, 4));
 269                 {
 270                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 272                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->info));
 273                         ndr->flags = _flags_save_DATA_BLOB;
 274                 }
 275                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 276         }
 277         if (ndr_flags & NDR_BUFFERS) {
 278         }
 279         return NDR_ERR_SUCCESS;
 280 }
 281
 282 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoFallBack(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoFallBack *r)
 283 {
 284         if (ndr_flags & NDR_SCALARS) {
 285                 NDR_CHECK(ndr_pull_align(ndr, 4));
 286                 {
 287                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 289                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->info));
 290                         ndr->flags = _flags_save_DATA_BLOB;
 291                 }
 292                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 293         }
 294         if (ndr_flags & NDR_BUFFERS) {
 295         }
 296         return NDR_ERR_SUCCESS;
 297 }
 298
 299 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoFallBack(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoFallBack *r)
 300 {
 301         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoFallBack");
 302         ndr->depth++;
 303         ndr_print_DATA_BLOB(ndr, "info", r->info);
 304         ndr->depth--;
 305 }
 306
 307 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsBindInfo *r)
 308 {
 309         if (ndr_flags & NDR_SCALARS) {
 310                 int level = ndr_push_get_switch_value(ndr, r);
 311                 NDR_CHECK(ndr_push_union_align(ndr, 1));
 312                 switch (level) {
 313                         case 24: {
 314                                 {
 315                                         struct ndr_push *_ndr_info24;
 316                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info24, 4, -1));
 317                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 318                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info24, 4, -1));
 319                                 }
 320                         break; }
 321
 322                         case 28: {
 323                                 {
 324                                         struct ndr_push *_ndr_info28;
 325                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info28, 4, -1));
 326                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 327                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info28, 4, -1));
 328                                 }
 329                         break; }
 330
 331                         case 48: {
 332                                 {
 333                                         struct ndr_push *_ndr_info48;
 334                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info48, 4, -1));
 335                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 336                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info48, 4, -1));
 337                                 }
 338                         break; }
 339
 340                         default: {
 341                                 {
 342                                         struct ndr_push *_ndr_FallBack;
 343                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 344                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 345                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 346                                 }
 347                         break; }
 348
 349                 }
 350         }
 351         if (ndr_flags & NDR_BUFFERS) {
 352                 int level = ndr_push_get_switch_value(ndr, r);
 353                 switch (level) {
 354                         case 24:
 355                         break;
 356
 357                         case 28:
 358                         break;
 359
 360                         case 48:
 361                         break;
 362
 363                         default:
 364                         break;
 365
 366                 }
 367         }
 368         return NDR_ERR_SUCCESS;
 369 }
 370
 371 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsBindInfo *r)
 372 {
 373         int level;
 374         level = ndr_pull_get_switch_value(ndr, r);
 375         if (ndr_flags & NDR_SCALARS) {
 376                 NDR_CHECK(ndr_pull_union_align(ndr, 1));
 377                 switch (level) {
 378                         case 24: {
 379                                 {
 380                                         struct ndr_pull *_ndr_info24;
 381                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info24, 4, -1));
 382                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 383                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info24, 4, -1));
 384                                 }
 385                         break; }
 386
 387                         case 28: {
 388                                 {
 389                                         struct ndr_pull *_ndr_info28;
 390                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info28, 4, -1));
 391                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 392                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info28, 4, -1));
 393                                 }
 394                         break; }
 395
 396                         case 48: {
 397                                 {
 398                                         struct ndr_pull *_ndr_info48;
 399                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info48, 4, -1));
 400                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 401                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info48, 4, -1));
 402                                 }
 403                         break; }
 404
 405                         default: {
 406                                 {
 407                                         struct ndr_pull *_ndr_FallBack;
 408                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 409                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 410                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 411                                 }
 412                         break; }
 413
 414                 }
 415         }
 416         if (ndr_flags & NDR_BUFFERS) {
 417                 switch (level) {
 418                         case 24:
 419                         break;
 420
 421                         case 28:
 422                         break;
 423
 424                         case 48:
 425                         break;
 426
 427                         default:
 428                         break;
 429
 430                 }
 431         }
 432         return NDR_ERR_SUCCESS;
 433 }
 434
 435 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsBindInfo *r)
 436 {
 437         int level;
 438         level = ndr_print_get_switch_value(ndr, r);
 439         ndr_print_union(ndr, name, level, "drsuapi_DsBindInfo");
 440         switch (level) {
 441                 case 24:
 442                         ndr_print_drsuapi_DsBindInfo24(ndr, "info24", &r->info24);
 443                 break;
 444
 445                 case 28:
 446                         ndr_print_drsuapi_DsBindInfo28(ndr, "info28", &r->info28);
 447                 break;
 448
 449                 case 48:
 450                         ndr_print_drsuapi_DsBindInfo48(ndr, "info48", &r->info48);
 451                 break;
 452
 453                 default:
 454                         ndr_print_drsuapi_DsBindInfoFallBack(ndr, "FallBack", &r->FallBack);
 455                 break;
 456
 457         }
 458 }
 459
 460 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoCtr *r)
 461 {
 462         if (ndr_flags & NDR_SCALARS) {
 463                 NDR_CHECK(ndr_push_align(ndr, 4));
 464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
 465                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->length));
 466                 NDR_CHECK(ndr_push_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 467                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 468         }
 469         if (ndr_flags & NDR_BUFFERS) {
 470         }
 471         return NDR_ERR_SUCCESS;
 472 }
 473
 474 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoCtr *r)
 475 {
 476         if (ndr_flags & NDR_SCALARS) {
 477                 NDR_CHECK(ndr_pull_align(ndr, 4));
 478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 479                 if (r->length < 1 || r->length > 10000) {
 480                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 481                 }
 482                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->length));
 483                 NDR_CHECK(ndr_pull_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 484                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 485         }
 486         if (ndr_flags & NDR_BUFFERS) {
 487         }
 488         return NDR_ERR_SUCCESS;
 489 }
 490
 491 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoCtr *r)
 492 {
 493         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoCtr");
 494         ndr->depth++;
 495         ndr_print_uint32(ndr, "length", r->length);
 496         ndr_print_set_switch_value(ndr, &r->info, r->length);
 497         ndr_print_drsuapi_DsBindInfo(ndr, "info", &r->info);
 498         ndr->depth--;
 499 }
 500
 501 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier *r)
 502 {
 503         if (ndr_flags & NDR_SCALARS) {
 504                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, strlen_m(r->dn) + 1));
 505                 NDR_CHECK(ndr_push_align(ndr, 4));
 506                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->iconv_convenience, ndr->flags) - 4));
 507                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
 508                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
 509                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
 510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
 511                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
 512                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 513         }
 514         if (ndr_flags & NDR_BUFFERS) {
 515                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
 516         }
 517         return NDR_ERR_SUCCESS;
 518 }
 519
 520 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier *r)
 521 {
 522         if (ndr_flags & NDR_SCALARS) {
 523                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dn));
 524                 NDR_CHECK(ndr_pull_align(ndr, 4));
 525                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
 526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
 527                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
 528                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
 529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
 530                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, ndr_get_array_size(ndr, &r->dn), sizeof(uint16_t), CH_UTF16));
 531                 if (r->dn) {
 532                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->dn, r->__ndr_size_dn + 1));
 533                 }
 534                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 535         }
 536         if (ndr_flags & NDR_BUFFERS) {
 537                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
 538         }
 539         return NDR_ERR_SUCCESS;
 540 }
 541
 542 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier *r)
 543 {
 544         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier");
 545         ndr->depth++;
 546         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);
 547         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);
 548         ndr_print_GUID(ndr, "guid", &r->guid);
 549         ndr_print_dom_sid28(ndr, "sid", &r->sid);
 550         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
 551         ndr_print_string(ndr, "dn", r->dn);
 552         ndr->depth--;
 553 }
 554
 555 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier(const struct drsuapi_DsReplicaObjectIdentifier *r, struct smb_iconv_convenience *ic, int flags)
 556 {
 557         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier, ic);
 558 }
 559
 560 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 561 {
 562         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 563         return NDR_ERR_SUCCESS;
 564 }
 565
 566 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 567 {
 568         uint32_t v;
 569         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 570         *r = v;
 571         return NDR_ERR_SUCCESS;
 572 }
 573
 574 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncOptions(struct ndr_print *ndr, const char *name, uint32_t r)
 575 {
 576         ndr_print_uint32(ndr, name, r);
 577         ndr->depth++;
 578         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION, r);
 579         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_WRITEABLE", DRSUAPI_DS_REPLICA_SYNC_WRITEABLE, r);
 580         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PERIODIC", DRSUAPI_DS_REPLICA_SYNC_PERIODIC, r);
 581         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING", DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING, r);
 582         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES", DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES, r);
 583         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL", DRSUAPI_DS_REPLICA_SYNC_FULL, r);
 584         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_URGENT", DRSUAPI_DS_REPLICA_SYNC_URGENT, r);
 585         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD", DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD, r);
 586         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FORCE", DRSUAPI_DS_REPLICA_SYNC_FORCE, r);
 587         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE", DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE, r);
 588         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED", DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED, r);
 589         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_TWO_WAY", DRSUAPI_DS_REPLICA_SYNC_TWO_WAY, r);
 590         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY", DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY, r);
 591         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL", DRSUAPI_DS_REPLICA_SYNC_INITIAL, r);
 592         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION", DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION, r);
 593         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ABANDONED", DRSUAPI_DS_REPLICA_SYNC_ABANDONED, r);
 594         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS, r);
 595         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET", DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET, r);
 596         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_REQUEUE", DRSUAPI_DS_REPLICA_SYNC_REQUEUE, r);
 597         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION", DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION, r);
 598         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA, r);
 599         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_CRITICAL", DRSUAPI_DS_REPLICA_SYNC_CRITICAL, r);
 600         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS, r);
 601         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PREEMPTED", DRSUAPI_DS_REPLICA_SYNC_PREEMPTED, r);
 602         ndr->depth--;
 603 }
 604
 605 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaSyncRequest1 *r)
 606 {
 607         if (ndr_flags & NDR_SCALARS) {
 608                 NDR_CHECK(ndr_push_align(ndr, 5));
 609                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
 610                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 611                 {
 612                         uint32_t _flags_save_string = ndr->flags;
 613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 614                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_info));
 615                         ndr->flags = _flags_save_string;
 616                 }
 617                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->options));
 618                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 619         }
 620         if (ndr_flags & NDR_BUFFERS) {
 621                 if (r->naming_context) {
 622                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 623                 }
 624                 {
 625                         uint32_t _flags_save_string = ndr->flags;
 626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 627                         if (r->other_info) {
 628                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->other_info));
 629                         }
 630                         ndr->flags = _flags_save_string;
 631                 }
 632         }
 633         return NDR_ERR_SUCCESS;
 634 }
 635
 636 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaSyncRequest1 *r)
 637 {
 638         uint32_t _ptr_naming_context;
 639         TALLOC_CTX *_mem_save_naming_context_0;
 640         uint32_t _ptr_other_info;
 641         TALLOC_CTX *_mem_save_other_info_0;
 642         if (ndr_flags & NDR_SCALARS) {
 643                 NDR_CHECK(ndr_pull_align(ndr, 5));
 644                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
 645                 if (_ptr_naming_context) {
 646                         NDR_PULL_ALLOC(ndr, r->naming_context);
 647                 } else {
 648                         r->naming_context = NULL;
 649                 }
 650                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 651                 {
 652                         uint32_t _flags_save_string = ndr->flags;
 653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 654                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_info));
 655                         if (_ptr_other_info) {
 656                                 NDR_PULL_ALLOC(ndr, r->other_info);
 657                         } else {
 658                                 r->other_info = NULL;
 659                         }
 660                         ndr->flags = _flags_save_string;
 661                 }
 662                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->options));
 663                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 664         }
 665         if (ndr_flags & NDR_BUFFERS) {
 666                 if (r->naming_context) {
 667                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
 668                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
 669                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 670                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
 671                 }
 672                 {
 673                         uint32_t _flags_save_string = ndr->flags;
 674                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 675                         if (r->other_info) {
 676                                 _mem_save_other_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 677                                 NDR_PULL_SET_MEM_CTX(ndr, r->other_info, 0);
 678                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->other_info));
 679                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_info_0, 0);
 680                         }
 681                         ndr->flags = _flags_save_string;
 682                 }
 683         }
 684         return NDR_ERR_SUCCESS;
 685 }
 686
 687 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaSyncRequest1 *r)
 688 {
 689         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSyncRequest1");
 690         ndr->depth++;
 691         ndr_print_ptr(ndr, "naming_context", r->naming_context);
 692         ndr->depth++;
 693         if (r->naming_context) {
 694                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
 695         }
 696         ndr->depth--;
 697         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
 698         ndr_print_ptr(ndr, "other_info", r->other_info);
 699         ndr->depth++;
 700         if (r->other_info) {
 701                 ndr_print_string(ndr, "other_info", r->other_info);
 702         }
 703         ndr->depth--;
 704         ndr_print_drsuapi_DsReplicaSyncOptions(ndr, "options", r->options);
 705         ndr->depth--;
 706 }
 707
 708 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaSyncRequest *r)
 709 {
 710         if (ndr_flags & NDR_SCALARS) {
 711                 int level = ndr_push_get_switch_value(ndr, r);
 712                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
 713                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 714                 switch (level) {
 715                         case 1: {
 716                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 717                         break; }
 718
 719                         default:
 720                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 721                 }
 722         }
 723         if (ndr_flags & NDR_BUFFERS) {
 724                 int level = ndr_push_get_switch_value(ndr, r);
 725                 switch (level) {
 726                         case 1:
 727                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 728                         break;
 729
 730                         default:
 731                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 732                 }
 733         }
 734         return NDR_ERR_SUCCESS;
 735 }
 736
 737 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaSyncRequest *r)
 738 {
 739         int level;
 740         int32_t _level;
 741         level = ndr_pull_get_switch_value(ndr, r);
 742         if (ndr_flags & NDR_SCALARS) {
 743                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
 744                 if (_level != level) {
 745                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 746                 }
 747                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 748                 switch (level) {
 749                         case 1: {
 750                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 751                         break; }
 752
 753                         default:
 754                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 755                 }
 756         }
 757         if (ndr_flags & NDR_BUFFERS) {
 758                 switch (level) {
 759                         case 1:
 760                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 761                         break;
 762
 763                         default:
 764                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 765                 }
 766         }
 767         return NDR_ERR_SUCCESS;
 768 }
 769
 770 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaSyncRequest *r)
 771 {
 772         int level;
 773         level = ndr_print_get_switch_value(ndr, r);
 774         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaSyncRequest");
 775         switch (level) {
 776                 case 1:
 777                         ndr_print_drsuapi_DsReplicaSyncRequest1(ndr, "req1", &r->req1);
 778                 break;
 779
 780                 default:
 781                         ndr_print_bad_level(ndr, name, level);
 782         }
 783 }
 784
 785 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaHighWaterMark(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaHighWaterMark *r)
 786 {
 787         if (ndr_flags & NDR_SCALARS) {
 788                 NDR_CHECK(ndr_push_align(ndr, 8));
 789                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
 790                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->reserved_usn));
 791                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 792                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 793         }
 794         if (ndr_flags & NDR_BUFFERS) {
 795         }
 796         return NDR_ERR_SUCCESS;
 797 }
 798
 799 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaHighWaterMark(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaHighWaterMark *r)
 800 {
 801         if (ndr_flags & NDR_SCALARS) {
 802                 NDR_CHECK(ndr_pull_align(ndr, 8));
 803                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
 804                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->reserved_usn));
 805                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 806                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 807         }
 808         if (ndr_flags & NDR_BUFFERS) {
 809         }
 810         return NDR_ERR_SUCCESS;
 811 }
 812
 813 _PUBLIC_ void ndr_print_drsuapi_DsReplicaHighWaterMark(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaHighWaterMark *r)
 814 {
 815         ndr_print_struct(ndr, name, "drsuapi_DsReplicaHighWaterMark");
 816         ndr->depth++;
 817         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
 818         ndr_print_hyper(ndr, "reserved_usn", r->reserved_usn);
 819         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 820         ndr->depth--;
 821 }
 822
 823 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor *r)
 824 {
 825         if (ndr_flags & NDR_SCALARS) {
 826                 NDR_CHECK(ndr_push_align(ndr, 8));
 827                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 828                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 829                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 830         }
 831         if (ndr_flags & NDR_BUFFERS) {
 832         }
 833         return NDR_ERR_SUCCESS;
 834 }
 835
 836 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor *r)
 837 {
 838         if (ndr_flags & NDR_SCALARS) {
 839                 NDR_CHECK(ndr_pull_align(ndr, 8));
 840                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 841                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 842                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 843         }
 844         if (ndr_flags & NDR_BUFFERS) {
 845         }
 846         return NDR_ERR_SUCCESS;
 847 }
 848
 849 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor *r)
 850 {
 851         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor");
 852         ndr->depth++;
 853         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
 854         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 855         ndr->depth--;
 856 }
 857
 858 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtrEx *r)
 859 {
 860         uint32_t cntr_cursors_0;
 861         if (ndr_flags & NDR_SCALARS) {
 862                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 863                 NDR_CHECK(ndr_push_align(ndr, 8));
 864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
 865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 868                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 869                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 870                 }
 871                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 872         }
 873         if (ndr_flags & NDR_BUFFERS) {
 874         }
 875         return NDR_ERR_SUCCESS;
 876 }
 877
 878 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtrEx *r)
 879 {
 880         uint32_t cntr_cursors_0;
 881         TALLOC_CTX *_mem_save_cursors_0;
 882         if (ndr_flags & NDR_SCALARS) {
 883                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
 884                 NDR_CHECK(ndr_pull_align(ndr, 8));
 885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 886                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 887                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 888                 if (r->count > 0x100000) {
 889                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 890                 }
 891                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 892                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
 893                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
 894                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
 895                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 896                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 897                 }
 898                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
 899                 if (r->cursors) {
 900                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
 901                 }
 902                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 903         }
 904         if (ndr_flags & NDR_BUFFERS) {
 905         }
 906         return NDR_ERR_SUCCESS;
 907 }
 908
 909 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtrEx *r)
 910 {
 911         uint32_t cntr_cursors_0;
 912         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtrEx");
 913         ndr->depth++;
 914         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
 915         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
 916         ndr_print_uint32(ndr, "count", r->count);
 917         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
 918         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
 919         ndr->depth++;
 920         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
 921                 char *idx_0=NULL;
 922                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
 923                         ndr_print_drsuapi_DsReplicaCursor(ndr, "cursors", &r->cursors[cntr_cursors_0]);
 924                         free(idx_0);
 925                 }
 926         }
 927         ndr->depth--;
 928         ndr->depth--;
 929 }
 930
 931 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 932 {
 933         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 934         return NDR_ERR_SUCCESS;
 935 }
 936
 937 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 938 {
 939         uint32_t v;
 940         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 941         *r = v;
 942         return NDR_ERR_SUCCESS;
 943 }
 944
 945 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 946 {
 947         ndr_print_uint32(ndr, name, r);
 948         ndr->depth++;
 949         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE", DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE, r);
 950         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP", DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP, r);
 951         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS", DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS, r);
 952         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_USE_ASYNC_INTERSIDE_TRANSPORT", DRSUAPI_DS_REPLICA_NEIGHBOUR_USE_ASYNC_INTERSIDE_TRANSPORT, r);
 953         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_ASYNC_REP", DRSUAPI_DS_REPLICA_NEIGHBOUR_ASYNC_REP, r);
 954         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_ERROR", DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_ERROR, r);
 955         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_TWO_WAY_SYNC", DRSUAPI_DS_REPLICA_NEIGHBOUR_TWO_WAY_SYNC, r);
 956         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_CRITICAL_ONLY", DRSUAPI_DS_REPLICA_NEIGHBOUR_CRITICAL_ONLY, r);
 957         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_RETURN_OBJECT_PARENTS", DRSUAPI_DS_REPLICA_NEIGHBOUR_RETURN_OBJECT_PARENTS, r);
 958         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS", DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS, r);
 959         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_SYNC_PACKET", DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_SYNC_PACKET, r);
 960         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED", DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED, r);
 961         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_SPECIAL_SECRET_PROCESSING", DRSUAPI_DS_REPLICA_NEIGHBOUR_SPECIAL_SECRET_PROCESSING, r);
 962         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_PREEMPTED", DRSUAPI_DS_REPLICA_NEIGHBOUR_PREEMPTED, r);
 963         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_CHANGE_NOTIFICATIONS", DRSUAPI_DS_REPLICA_NEIGHBOUR_IGNORE_CHANGE_NOTIFICATIONS, r);
 964         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_DISABLE_SCHEDULED_SYNC", DRSUAPI_DS_REPLICA_NEIGHBOUR_DISABLE_SCHEDULED_SYNC, r);
 965         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES", DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES, r);
 966         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_NO_CHANGE_NOTIFICATIONS", DRSUAPI_DS_REPLICA_NEIGHBOUR_NO_CHANGE_NOTIFICATIONS, r);
 967         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_NEIGHBOUR_PARTIAL_ATTRIBUTE_SET", DRSUAPI_DS_REPLICA_NEIGHBOUR_PARTIAL_ATTRIBUTE_SET, r);
 968         ndr->depth--;
 969 }
 970
 971 static enum ndr_err_code ndr_push_drsuapi_DsExtendedOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation r)
 972 {
 973         {
 974                 uint32_t _flags_save_ENUM = ndr->flags;
 975                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 976                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 977                 ndr->flags = _flags_save_ENUM;
 978         }
 979         return NDR_ERR_SUCCESS;
 980 }
 981
 982 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation *r)
 983 {
 984         uint32_t v;
 985         {
 986                 uint32_t _flags_save_ENUM = ndr->flags;
 987                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 988                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 989                 *r = v;
 990                 ndr->flags = _flags_save_ENUM;
 991         }
 992         return NDR_ERR_SUCCESS;
 993 }
 994
 995 _PUBLIC_ void ndr_print_drsuapi_DsExtendedOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedOperation r)
 996 {
 997         const char *val = NULL;
 998
 999         {
1000                 uint32_t _flags_save_ENUM = ndr->flags;
1001                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1002                 switch (r) {
1003                         case DRSUAPI_EXOP_NONE: val = "DRSUAPI_EXOP_NONE"; break;
1004                         case DRSUAPI_EXOP_FSMO_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_REQ_ROLE"; break;
1005                         case DRSUAPI_EXOP_FSMO_RID_ALLOC: val = "DRSUAPI_EXOP_FSMO_RID_ALLOC"; break;
1006                         case DRSUAPI_EXOP_FSMO_RID_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_RID_REQ_ROLE"; break;
1007                         case DRSUAPI_EXOP_FSMO_REQ_PDC: val = "DRSUAPI_EXOP_FSMO_REQ_PDC"; break;
1008                         case DRSUAPI_EXOP_FSMO_ABANDON_ROLE: val = "DRSUAPI_EXOP_FSMO_ABANDON_ROLE"; break;
1009                         case DRSUAPI_EXOP_REPL_OBJ: val = "DRSUAPI_EXOP_REPL_OBJ"; break;
1010                         case DRSUAPI_EXOP_REPL_SECRET: val = "DRSUAPI_EXOP_REPL_SECRET"; break;
1011                 }
1012                 ndr_print_enum(ndr, name, "ENUM", val, r);
1013                 ndr->flags = _flags_save_ENUM;
1014         }
1015 }
1016
1017 static enum ndr_err_code ndr_push_drsuapi_DsExtendedError(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedError r)
1018 {
1019         {
1020                 uint32_t _flags_save_ENUM = ndr->flags;
1021                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1022                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1023                 ndr->flags = _flags_save_ENUM;
1024         }
1025         return NDR_ERR_SUCCESS;
1026 }
1027
1028 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedError(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedError *r)
1029 {
1030         uint32_t v;
1031         {
1032                 uint32_t _flags_save_ENUM = ndr->flags;
1033                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1034                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1035                 *r = v;
1036                 ndr->flags = _flags_save_ENUM;
1037         }
1038         return NDR_ERR_SUCCESS;
1039 }
1040
1041 _PUBLIC_ void ndr_print_drsuapi_DsExtendedError(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedError r)
1042 {
1043         const char *val = NULL;
1044
1045         {
1046                 uint32_t _flags_save_ENUM = ndr->flags;
1047                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1048                 switch (r) {
1049                         case DRSUAPI_EXOP_ERR_NONE: val = "DRSUAPI_EXOP_ERR_NONE"; break;
1050                         case DRSUAPI_EXOP_ERR_SUCCESS: val = "DRSUAPI_EXOP_ERR_SUCCESS"; break;
1051                         case DRSUAPI_EXOP_ERR_UNKNOWN_OP: val = "DRSUAPI_EXOP_ERR_UNKNOWN_OP"; break;
1052                         case DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER: val = "DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER"; break;
1053                         case DRSUAPI_EXOP_ERR_UPDATE_ERR: val = "DRSUAPI_EXOP_ERR_UPDATE_ERR"; break;
1054                         case DRSUAPI_EXOP_ERR_EXCEPTION: val = "DRSUAPI_EXOP_ERR_EXCEPTION"; break;
1055                         case DRSUAPI_EXOP_ERR_UNKNOWN_CALLER: val = "DRSUAPI_EXOP_ERR_UNKNOWN_CALLER"; break;
1056                         case DRSUAPI_EXOP_ERR_RID_ALLOC: val = "DRSUAPI_EXOP_ERR_RID_ALLOC"; break;
1057                         case DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED: val = "DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED"; break;
1058                         case DRSUAPI_EXOP_ERR_FMSO_PENDING_OP: val = "DRSUAPI_EXOP_ERR_FMSO_PENDING_OP"; break;
1059                         case DRSUAPI_EXOP_ERR_MISMATCH: val = "DRSUAPI_EXOP_ERR_MISMATCH"; break;
1060                         case DRSUAPI_EXOP_ERR_COULDNT_CONTACT: val = "DRSUAPI_EXOP_ERR_COULDNT_CONTACT"; break;
1061                         case DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES: val = "DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES"; break;
1062                         case DRSUAPI_EXOP_ERR_DIR_ERROR: val = "DRSUAPI_EXOP_ERR_DIR_ERROR"; break;
1063                         case DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS: val = "DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS"; break;
1064                         case DRSUAPI_EXOP_ERR_ACCESS_DENIED: val = "DRSUAPI_EXOP_ERR_ACCESS_DENIED"; break;
1065                         case DRSUAPI_EXOP_ERR_PARAM_ERROR: val = "DRSUAPI_EXOP_ERR_PARAM_ERROR"; break;
1066                 }
1067                 ndr_print_enum(ndr, name, "ENUM", val, r);
1068                 ndr->flags = _flags_save_ENUM;
1069         }
1070 }
1071
1072 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest5(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest5 *r)
1073 {
1074         if (ndr_flags & NDR_SCALARS) {
1075                 NDR_CHECK(ndr_push_align(ndr, 8));
1076                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1077                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1078                 if (r->naming_context == NULL) {
1079                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1080                 }
1081                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1082                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1083                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1084                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1087                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1088                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1089                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1090         }
1091         if (ndr_flags & NDR_BUFFERS) {
1092                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1093                 if (r->uptodateness_vector) {
1094                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1095                 }
1096         }
1097         return NDR_ERR_SUCCESS;
1098 }
1099
1100 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest5(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest5 *r)
1101 {
1102         uint32_t _ptr_naming_context;
1103         TALLOC_CTX *_mem_save_naming_context_0;
1104         uint32_t _ptr_uptodateness_vector;
1105         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1106         if (ndr_flags & NDR_SCALARS) {
1107                 NDR_CHECK(ndr_pull_align(ndr, 8));
1108                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1109                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1110                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1111                 if (_ptr_naming_context) {
1112                         NDR_PULL_ALLOC(ndr, r->naming_context);
1113                 } else {
1114                         r->naming_context = NULL;
1115                 }
1116                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1117                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1118                 if (_ptr_uptodateness_vector) {
1119                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1120                 } else {
1121                         r->uptodateness_vector = NULL;
1122                 }
1123                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1126                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1127                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1128                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1129         }
1130         if (ndr_flags & NDR_BUFFERS) {
1131                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1132                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1133                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1134                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1135                 if (r->uptodateness_vector) {
1136                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1137                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1138                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1139                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1140                 }
1141         }
1142         return NDR_ERR_SUCCESS;
1143 }
1144
1145 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest5(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest5 *r)
1146 {
1147         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest5");
1148         ndr->depth++;
1149         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1150         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1151         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1152         ndr->depth++;
1153         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1154         ndr->depth--;
1155         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1156         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1157         ndr->depth++;
1158         if (r->uptodateness_vector) {
1159                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1160         }
1161         ndr->depth--;
1162         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1163         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1164         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1165         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1166         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1167         ndr->depth--;
1168 }
1169
1170 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOID(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOID *r)
1171 {
1172         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOID");
1173         ndr->depth++;
1174         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaOID_oid(r->oid, 0):r->__ndr_size);
1175         ndr_print_ptr(ndr, "oid", r->oid);
1176         ndr->depth++;
1177         if (r->oid) {
1178                 ndr_print_string(ndr, "oid", r->oid);
1179         }
1180         ndr->depth--;
1181         ndr->depth--;
1182 }
1183
1184 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping *r)
1185 {
1186         if (ndr_flags & NDR_SCALARS) {
1187                 NDR_CHECK(ndr_push_align(ndr, 5));
1188                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id_prefix));
1189                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1190                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1191         }
1192         if (ndr_flags & NDR_BUFFERS) {
1193                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1194         }
1195         return NDR_ERR_SUCCESS;
1196 }
1197
1198 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping *r)
1199 {
1200         if (ndr_flags & NDR_SCALARS) {
1201                 NDR_CHECK(ndr_pull_align(ndr, 5));
1202                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id_prefix));
1203                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1204                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1205         }
1206         if (ndr_flags & NDR_BUFFERS) {
1207                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1208         }
1209         return NDR_ERR_SUCCESS;
1210 }
1211
1212 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping *r)
1213 {
1214         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping");
1215         ndr->depth++;
1216         ndr_print_uint32(ndr, "id_prefix", r->id_prefix);
1217         ndr_print_drsuapi_DsReplicaOID(ndr, "oid", &r->oid);
1218         ndr->depth--;
1219 }
1220
1221 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1222 {
1223         uint32_t cntr_mappings_1;
1224         if (ndr_flags & NDR_SCALARS) {
1225                 NDR_CHECK(ndr_push_align(ndr, 5));
1226                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
1227                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mappings));
1228                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1229         }
1230         if (ndr_flags & NDR_BUFFERS) {
1231                 if (r->mappings) {
1232                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_mappings));
1233                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1234                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1235                         }
1236                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1237                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1238                         }
1239                 }
1240         }
1241         return NDR_ERR_SUCCESS;
1242 }
1243
1244 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1245 {
1246         uint32_t _ptr_mappings;
1247         uint32_t cntr_mappings_1;
1248         TALLOC_CTX *_mem_save_mappings_0;
1249         TALLOC_CTX *_mem_save_mappings_1;
1250         if (ndr_flags & NDR_SCALARS) {
1251                 NDR_CHECK(ndr_pull_align(ndr, 5));
1252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mappings));
1253                 if (r->num_mappings > 0x100000) {
1254                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1255                 }
1256                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mappings));
1257                 if (_ptr_mappings) {
1258                         NDR_PULL_ALLOC(ndr, r->mappings);
1259                 } else {
1260                         r->mappings = NULL;
1261                 }
1262                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1263         }
1264         if (ndr_flags & NDR_BUFFERS) {
1265                 if (r->mappings) {
1266                         _mem_save_mappings_0 = NDR_PULL_GET_MEM_CTX(ndr);
1267                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mappings));
1269                         NDR_PULL_ALLOC_N(ndr, r->mappings, ndr_get_array_size(ndr, &r->mappings));
1270                         _mem_save_mappings_1 = NDR_PULL_GET_MEM_CTX(ndr);
1271                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1272                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1273                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1274                         }
1275                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1276                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1277                         }
1278                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_1, 0);
1279                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_0, 0);
1280                 }
1281                 if (r->mappings) {
1282                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->mappings, r->num_mappings));
1283                 }
1284         }
1285         return NDR_ERR_SUCCESS;
1286 }
1287
1288 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1289 {
1290         uint32_t cntr_mappings_1;
1291         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping_Ctr");
1292         ndr->depth++;
1293         ndr_print_uint32(ndr, "num_mappings", r->num_mappings);
1294         ndr_print_ptr(ndr, "mappings", r->mappings);
1295         ndr->depth++;
1296         if (r->mappings) {
1297                 ndr->print(ndr, "%s: ARRAY(%d)", "mappings", (int)r->num_mappings);
1298                 ndr->depth++;
1299                 for (cntr_mappings_1=0;cntr_mappings_1<r->num_mappings;cntr_mappings_1++) {
1300                         char *idx_1=NULL;
1301                         if (asprintf(&idx_1, "[%d]", cntr_mappings_1) != -1) {
1302                                 ndr_print_drsuapi_DsReplicaOIDMapping(ndr, "mappings", &r->mappings[cntr_mappings_1]);
1303                                 free(idx_1);
1304                         }
1305                 }
1306                 ndr->depth--;
1307         }
1308         ndr->depth--;
1309         ndr->depth--;
1310 }
1311
1312 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAttributeId(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsAttributeId r)
1313 {
1314         {
1315                 uint32_t _flags_save_ENUM = ndr->flags;
1316                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1317                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1318                 ndr->flags = _flags_save_ENUM;
1319         }
1320         return NDR_ERR_SUCCESS;
1321 }
1322
1323 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAttributeId(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsAttributeId *r)
1324 {
1325         uint32_t v;
1326         {
1327                 uint32_t _flags_save_ENUM = ndr->flags;
1328                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1329                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1330                 *r = v;
1331                 ndr->flags = _flags_save_ENUM;
1332         }
1333         return NDR_ERR_SUCCESS;
1334 }
1335
1336 _PUBLIC_ void ndr_print_drsuapi_DsAttributeId(struct ndr_print *ndr, const char *name, enum drsuapi_DsAttributeId r)
1337 {
1338         const char *val = NULL;
1339
1340         {
1341                 uint32_t _flags_save_ENUM = ndr->flags;
1342                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1343                 switch (r) {
1344                         case DRSUAPI_ATTRIBUTE_objectClass: val = "DRSUAPI_ATTRIBUTE_objectClass"; break;
1345                         case DRSUAPI_ATTRIBUTE_description: val = "DRSUAPI_ATTRIBUTE_description"; break;
1346                         case DRSUAPI_ATTRIBUTE_member: val = "DRSUAPI_ATTRIBUTE_member"; break;
1347                         case DRSUAPI_ATTRIBUTE_instanceType: val = "DRSUAPI_ATTRIBUTE_instanceType"; break;
1348                         case DRSUAPI_ATTRIBUTE_whenCreated: val = "DRSUAPI_ATTRIBUTE_whenCreated"; break;
1349                         case DRSUAPI_ATTRIBUTE_possSuperiors: val = "DRSUAPI_ATTRIBUTE_possSuperiors"; break;
1350                         case DRSUAPI_ATTRIBUTE_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_hasMasterNCs"; break;
1351                         case DRSUAPI_ATTRIBUTE_subClassOf: val = "DRSUAPI_ATTRIBUTE_subClassOf"; break;
1352                         case DRSUAPI_ATTRIBUTE_governsID: val = "DRSUAPI_ATTRIBUTE_governsID"; break;
1353                         case DRSUAPI_ATTRIBUTE_mustContain: val = "DRSUAPI_ATTRIBUTE_mustContain"; break;
1354                         case DRSUAPI_ATTRIBUTE_mayContain: val = "DRSUAPI_ATTRIBUTE_mayContain"; break;
1355                         case DRSUAPI_ATTRIBUTE_attributeID: val = "DRSUAPI_ATTRIBUTE_attributeID"; break;
1356                         case DRSUAPI_ATTRIBUTE_attributeSyntax: val = "DRSUAPI_ATTRIBUTE_attributeSyntax"; break;
1357                         case DRSUAPI_ATTRIBUTE_isSingleValued: val = "DRSUAPI_ATTRIBUTE_isSingleValued"; break;
1358                         case DRSUAPI_ATTRIBUTE_rangeLower: val = "DRSUAPI_ATTRIBUTE_rangeLower"; break;
1359                         case DRSUAPI_ATTRIBUTE_rangeUpper: val = "DRSUAPI_ATTRIBUTE_rangeUpper"; break;
1360                         case DRSUAPI_ATTRIBUTE_dMDLocation: val = "DRSUAPI_ATTRIBUTE_dMDLocation"; break;
1361                         case DRSUAPI_ATTRIBUTE_objectVersion: val = "DRSUAPI_ATTRIBUTE_objectVersion"; break;
1362                         case DRSUAPI_ATTRIBUTE_invocationId: val = "DRSUAPI_ATTRIBUTE_invocationId"; break;
1363                         case DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly: val = "DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly"; break;
1364                         case DRSUAPI_ATTRIBUTE_adminDisplayName: val = "DRSUAPI_ATTRIBUTE_adminDisplayName"; break;
1365                         case DRSUAPI_ATTRIBUTE_adminDescription: val = "DRSUAPI_ATTRIBUTE_adminDescription"; break;
1366                         case DRSUAPI_ATTRIBUTE_oMSyntax: val = "DRSUAPI_ATTRIBUTE_oMSyntax"; break;
1367                         case DRSUAPI_ATTRIBUTE_ntSecurityDescriptor: val = "DRSUAPI_ATTRIBUTE_ntSecurityDescriptor"; break;
1368                         case DRSUAPI_ATTRIBUTE_searchFlags: val = "DRSUAPI_ATTRIBUTE_searchFlags"; break;
1369                         case DRSUAPI_ATTRIBUTE_auxiliaryClass: val = "DRSUAPI_ATTRIBUTE_auxiliaryClass"; break;
1370                         case DRSUAPI_ATTRIBUTE_lDAPDisplayName: val = "DRSUAPI_ATTRIBUTE_lDAPDisplayName"; break;
1371                         case DRSUAPI_ATTRIBUTE_name: val = "DRSUAPI_ATTRIBUTE_name"; break;
1372                         case DRSUAPI_ATTRIBUTE_userAccountControl: val = "DRSUAPI_ATTRIBUTE_userAccountControl"; break;
1373                         case DRSUAPI_ATTRIBUTE_currentValue: val = "DRSUAPI_ATTRIBUTE_currentValue"; break;
1374                         case DRSUAPI_ATTRIBUTE_homeDirectory: val = "DRSUAPI_ATTRIBUTE_homeDirectory"; break;
1375                         case DRSUAPI_ATTRIBUTE_homeDrive: val = "DRSUAPI_ATTRIBUTE_homeDrive"; break;
1376                         case DRSUAPI_ATTRIBUTE_scriptPath: val = "DRSUAPI_ATTRIBUTE_scriptPath"; break;
1377                         case DRSUAPI_ATTRIBUTE_profilePath: val = "DRSUAPI_ATTRIBUTE_profilePath"; break;
1378                         case DRSUAPI_ATTRIBUTE_objectSid: val = "DRSUAPI_ATTRIBUTE_objectSid"; break;
1379                         case DRSUAPI_ATTRIBUTE_schemaIDGUID: val = "DRSUAPI_ATTRIBUTE_schemaIDGUID"; break;
1380                         case DRSUAPI_ATTRIBUTE_dBCSPwd: val = "DRSUAPI_ATTRIBUTE_dBCSPwd"; break;
1381                         case DRSUAPI_ATTRIBUTE_logonHours: val = "DRSUAPI_ATTRIBUTE_logonHours"; break;
1382                         case DRSUAPI_ATTRIBUTE_userWorkstations: val = "DRSUAPI_ATTRIBUTE_userWorkstations"; break;
1383                         case DRSUAPI_ATTRIBUTE_unicodePwd: val = "DRSUAPI_ATTRIBUTE_unicodePwd"; break;
1384                         case DRSUAPI_ATTRIBUTE_ntPwdHistory: val = "DRSUAPI_ATTRIBUTE_ntPwdHistory"; break;
1385                         case DRSUAPI_ATTRIBUTE_priorValue: val = "DRSUAPI_ATTRIBUTE_priorValue"; break;
1386                         case DRSUAPI_ATTRIBUTE_supplementalCredentials: val = "DRSUAPI_ATTRIBUTE_supplementalCredentials"; break;
1387                         case DRSUAPI_ATTRIBUTE_trustAuthIncoming: val = "DRSUAPI_ATTRIBUTE_trustAuthIncoming"; break;
1388                         case DRSUAPI_ATTRIBUTE_trustAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_trustAuthOutgoing"; break;
1389                         case DRSUAPI_ATTRIBUTE_lmPwdHistory: val = "DRSUAPI_ATTRIBUTE_lmPwdHistory"; break;
1390                         case DRSUAPI_ATTRIBUTE_systemPossSuperiors: val = "DRSUAPI_ATTRIBUTE_systemPossSuperiors"; break;
1391                         case DRSUAPI_ATTRIBUTE_systemMayContain: val = "DRSUAPI_ATTRIBUTE_systemMayContain"; break;
1392                         case DRSUAPI_ATTRIBUTE_systemMustContain: val = "DRSUAPI_ATTRIBUTE_systemMustContain"; break;
1393                         case DRSUAPI_ATTRIBUTE_sAMAccountName: val = "DRSUAPI_ATTRIBUTE_sAMAccountName"; break;
1394                         case DRSUAPI_ATTRIBUTE_sAMAccountType: val = "DRSUAPI_ATTRIBUTE_sAMAccountType"; break;
1395                         case DRSUAPI_ATTRIBUTE_fSMORoleOwner: val = "DRSUAPI_ATTRIBUTE_fSMORoleOwner"; break;
1396                         case DRSUAPI_ATTRIBUTE_systemFlags: val = "DRSUAPI_ATTRIBUTE_systemFlags"; break;
1397                         case DRSUAPI_ATTRIBUTE_serverReference: val = "DRSUAPI_ATTRIBUTE_serverReference"; break;
1398                         case DRSUAPI_ATTRIBUTE_serverReferenceBL: val = "DRSUAPI_ATTRIBUTE_serverReferenceBL"; break;
1399                         case DRSUAPI_ATTRIBUTE_initialAuthIncoming: val = "DRSUAPI_ATTRIBUTE_initialAuthIncoming"; break;
1400                         case DRSUAPI_ATTRIBUTE_initialAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_initialAuthOutgoing"; break;
1401                         case DRSUAPI_ATTRIBUTE_wellKnownObjects: val = "DRSUAPI_ATTRIBUTE_wellKnownObjects"; break;
1402                         case DRSUAPI_ATTRIBUTE_dNSHostName: val = "DRSUAPI_ATTRIBUTE_dNSHostName"; break;
1403                         case DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet: val = "DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet"; break;
1404                         case DRSUAPI_ATTRIBUTE_userPrincipalName: val = "DRSUAPI_ATTRIBUTE_userPrincipalName"; break;
1405                         case DRSUAPI_ATTRIBUTE_groupType: val = "DRSUAPI_ATTRIBUTE_groupType"; break;
1406                         case DRSUAPI_ATTRIBUTE_servicePrincipalName: val = "DRSUAPI_ATTRIBUTE_servicePrincipalName"; break;
1407                         case DRSUAPI_ATTRIBUTE_objectCategory: val = "DRSUAPI_ATTRIBUTE_objectCategory"; break;
1408                         case DRSUAPI_ATTRIBUTE_gPLink: val = "DRSUAPI_ATTRIBUTE_gPLink"; break;
1409                         case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version: val = "DRSUAPI_ATTRIBUTE_msDS_Behavior_Version"; break;
1410                         case DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber: val = "DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber"; break;
1411                         case DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs: val = "DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs"; break;
1412                         case DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs"; break;
1413                 }
1414                 ndr_print_enum(ndr, name, "ENUM", val, r);
1415                 ndr->flags = _flags_save_ENUM;
1416         }
1417 }
1418
1419 static enum ndr_err_code ndr_push_drsuapi_DsPartialAttributeSet(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsPartialAttributeSet *r)
1420 {
1421         uint32_t cntr_attids_0;
1422         if (ndr_flags & NDR_SCALARS) {
1423                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attids));
1424                 NDR_CHECK(ndr_push_align(ndr, 4));
1425                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
1426                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1427                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
1428                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1429                         NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attids[cntr_attids_0]));
1430                 }
1431                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1432         }
1433         if (ndr_flags & NDR_BUFFERS) {
1434         }
1435         return NDR_ERR_SUCCESS;
1436 }
1437
1438 static enum ndr_err_code ndr_pull_drsuapi_DsPartialAttributeSet(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsPartialAttributeSet *r)
1439 {
1440         uint32_t cntr_attids_0;
1441         TALLOC_CTX *_mem_save_attids_0;
1442         if (ndr_flags & NDR_SCALARS) {
1443                 NDR_CHECK(ndr_pull_array_size(ndr, &r->attids));
1444                 NDR_CHECK(ndr_pull_align(ndr, 4));
1445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attids));
1448                 if (r->num_attids < 1 || r->num_attids > 0x100000) {
1449                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1450                 }
1451                 NDR_PULL_ALLOC_N(ndr, r->attids, ndr_get_array_size(ndr, &r->attids));
1452                 _mem_save_attids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1453                 NDR_PULL_SET_MEM_CTX(ndr, r->attids, 0);
1454                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1455                         NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attids[cntr_attids_0]));
1456                 }
1457                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attids_0, 0);
1458                 if (r->attids) {
1459                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attids, r->num_attids));
1460                 }
1461                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1462         }
1463         if (ndr_flags & NDR_BUFFERS) {
1464         }
1465         return NDR_ERR_SUCCESS;
1466 }
1467
1468 _PUBLIC_ void ndr_print_drsuapi_DsPartialAttributeSet(struct ndr_print *ndr, const char *name, const struct drsuapi_DsPartialAttributeSet *r)
1469 {
1470         uint32_t cntr_attids_0;
1471         ndr_print_struct(ndr, name, "drsuapi_DsPartialAttributeSet");
1472         ndr->depth++;
1473         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
1474         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1475         ndr_print_uint32(ndr, "num_attids", r->num_attids);
1476         ndr->print(ndr, "%s: ARRAY(%d)", "attids", (int)r->num_attids);
1477         ndr->depth++;
1478         for (cntr_attids_0=0;cntr_attids_0<r->num_attids;cntr_attids_0++) {
1479                 char *idx_0=NULL;
1480                 if (asprintf(&idx_0, "[%d]", cntr_attids_0) != -1) {
1481                         ndr_print_drsuapi_DsAttributeId(ndr, "attids", r->attids[cntr_attids_0]);
1482                         free(idx_0);
1483                 }
1484         }
1485         ndr->depth--;
1486         ndr->depth--;
1487 }
1488
1489 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest8(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest8 *r)
1490 {
1491         if (ndr_flags & NDR_SCALARS) {
1492                 NDR_CHECK(ndr_push_align(ndr, 8));
1493                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1494                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1495                 if (r->naming_context == NULL) {
1496                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1497                 }
1498                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1499                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1500                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1501                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1503                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1504                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1505                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1506                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1507                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1508                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1509                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1510         }
1511         if (ndr_flags & NDR_BUFFERS) {
1512                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1513                 if (r->uptodateness_vector) {
1514                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1515                 }
1516                 if (r->partial_attribute_set) {
1517                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1518                 }
1519                 if (r->partial_attribute_set_ex) {
1520                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1521                 }
1522                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1523         }
1524         return NDR_ERR_SUCCESS;
1525 }
1526
1527 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest8(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest8 *r)
1528 {
1529         uint32_t _ptr_naming_context;
1530         TALLOC_CTX *_mem_save_naming_context_0;
1531         uint32_t _ptr_uptodateness_vector;
1532         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1533         uint32_t _ptr_partial_attribute_set;
1534         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1535         uint32_t _ptr_partial_attribute_set_ex;
1536         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1537         if (ndr_flags & NDR_SCALARS) {
1538                 NDR_CHECK(ndr_pull_align(ndr, 8));
1539                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1540                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1541                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1542                 if (_ptr_naming_context) {
1543                         NDR_PULL_ALLOC(ndr, r->naming_context);
1544                 } else {
1545                         r->naming_context = NULL;
1546                 }
1547                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1548                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1549                 if (_ptr_uptodateness_vector) {
1550                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1551                 } else {
1552                         r->uptodateness_vector = NULL;
1553                 }
1554                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1556                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1557                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1558                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1559                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1560                 if (_ptr_partial_attribute_set) {
1561                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1562                 } else {
1563                         r->partial_attribute_set = NULL;
1564                 }
1565                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1566                 if (_ptr_partial_attribute_set_ex) {
1567                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1568                 } else {
1569                         r->partial_attribute_set_ex = NULL;
1570                 }
1571                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1572                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1573         }
1574         if (ndr_flags & NDR_BUFFERS) {
1575                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1576                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1577                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1578                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1579                 if (r->uptodateness_vector) {
1580                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1581                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1582                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1583                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1584                 }
1585                 if (r->partial_attribute_set) {
1586                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1587                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1588                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1589                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1590                 }
1591                 if (r->partial_attribute_set_ex) {
1592                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1593                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1594                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1595                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1596                 }
1597                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1598         }
1599         return NDR_ERR_SUCCESS;
1600 }
1601
1602 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest8(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest8 *r)
1603 {
1604         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest8");
1605         ndr->depth++;
1606         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1607         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1608         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1609         ndr->depth++;
1610         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1611         ndr->depth--;
1612         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1613         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1614         ndr->depth++;
1615         if (r->uptodateness_vector) {
1616                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1617         }
1618         ndr->depth--;
1619         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1620         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1621         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1622         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1623         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1624         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1625         ndr->depth++;
1626         if (r->partial_attribute_set) {
1627                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1628         }
1629         ndr->depth--;
1630         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1631         ndr->depth++;
1632         if (r->partial_attribute_set_ex) {
1633                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1634         }
1635         ndr->depth--;
1636         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1637         ndr->depth--;
1638 }
1639
1640 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest10(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest10 *r)
1641 {
1642         if (ndr_flags & NDR_SCALARS) {
1643                 NDR_CHECK(ndr_push_align(ndr, 8));
1644                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1645                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1646                 if (r->naming_context == NULL) {
1647                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1648                 }
1649                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1650                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1651                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1652                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1655                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1656                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1657                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1658                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1659                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1660                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_flags));
1661                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1662         }
1663         if (ndr_flags & NDR_BUFFERS) {
1664                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1665                 if (r->uptodateness_vector) {
1666                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1667                 }
1668                 if (r->partial_attribute_set) {
1669                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1670                 }
1671                 if (r->partial_attribute_set_ex) {
1672                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1673                 }
1674                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1675         }
1676         return NDR_ERR_SUCCESS;
1677 }
1678
1679 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest10(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest10 *r)
1680 {
1681         uint32_t _ptr_naming_context;
1682         TALLOC_CTX *_mem_save_naming_context_0;
1683         uint32_t _ptr_uptodateness_vector;
1684         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1685         uint32_t _ptr_partial_attribute_set;
1686         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1687         uint32_t _ptr_partial_attribute_set_ex;
1688         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1689         if (ndr_flags & NDR_SCALARS) {
1690                 NDR_CHECK(ndr_pull_align(ndr, 8));
1691                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1692                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1693                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1694                 if (_ptr_naming_context) {
1695                         NDR_PULL_ALLOC(ndr, r->naming_context);
1696                 } else {
1697                         r->naming_context = NULL;
1698                 }
1699                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1700                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1701                 if (_ptr_uptodateness_vector) {
1702                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1703                 } else {
1704                         r->uptodateness_vector = NULL;
1705                 }
1706                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1707                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1708                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1709                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1710                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1711                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1712                 if (_ptr_partial_attribute_set) {
1713                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1714                 } else {
1715                         r->partial_attribute_set = NULL;
1716                 }
1717                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1718                 if (_ptr_partial_attribute_set_ex) {
1719                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1720                 } else {
1721                         r->partial_attribute_set_ex = NULL;
1722                 }
1723                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1724                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_flags));
1725                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1726         }
1727         if (ndr_flags & NDR_BUFFERS) {
1728                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1729                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1730                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1731                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1732                 if (r->uptodateness_vector) {
1733                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1734                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1735                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1736                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1737                 }
1738                 if (r->partial_attribute_set) {
1739                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1740                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1741                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1742                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1743                 }
1744                 if (r->partial_attribute_set_ex) {
1745                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1746                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1747                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1749                 }
1750                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1751         }
1752         return NDR_ERR_SUCCESS;
1753 }
1754
1755 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest10(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest10 *r)
1756 {
1757         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest10");
1758         ndr->depth++;
1759         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1760         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1761         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1762         ndr->depth++;
1763         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1764         ndr->depth--;
1765         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1766         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1767         ndr->depth++;
1768         if (r->uptodateness_vector) {
1769                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1770         }
1771         ndr->depth--;
1772         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1773         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1774         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1775         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1776         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1777         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1778         ndr->depth++;
1779         if (r->partial_attribute_set) {
1780                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1781         }
1782         ndr->depth--;
1783         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1784         ndr->depth++;
1785         if (r->partial_attribute_set_ex) {
1786                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1787         }
1788         ndr->depth--;
1789         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1790         ndr_print_uint32(ndr, "more_flags", r->more_flags);
1791         ndr->depth--;
1792 }
1793
1794 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesRequest *r)
1795 {
1796         if (ndr_flags & NDR_SCALARS) {
1797                 int level = ndr_push_get_switch_value(ndr, r);
1798                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
1799                 NDR_CHECK(ndr_push_union_align(ndr, 8));
1800                 switch (level) {
1801                         case 5: {
1802                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1803                         break; }
1804
1805                         case 8: {
1806                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1807                         break; }
1808
1809                         case 10: {
1810                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1811                         break; }
1812
1813                         default:
1814                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1815                 }
1816         }
1817         if (ndr_flags & NDR_BUFFERS) {
1818                 int level = ndr_push_get_switch_value(ndr, r);
1819                 switch (level) {
1820                         case 5:
1821                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1822                         break;
1823
1824                         case 8:
1825                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1826                         break;
1827
1828                         case 10:
1829                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1830                         break;
1831
1832                         default:
1833                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1834                 }
1835         }
1836         return NDR_ERR_SUCCESS;
1837 }
1838
1839 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesRequest *r)
1840 {
1841         int level;
1842         int32_t _level;
1843         level = ndr_pull_get_switch_value(ndr, r);
1844         if (ndr_flags & NDR_SCALARS) {
1845                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
1846                 if (_level != level) {
1847                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1848                 }
1849                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
1850                 switch (level) {
1851                         case 5: {
1852                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1853                         break; }
1854
1855                         case 8: {
1856                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1857                         break; }
1858
1859                         case 10: {
1860                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1861                         break; }
1862
1863                         default:
1864                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1865                 }
1866         }
1867         if (ndr_flags & NDR_BUFFERS) {
1868                 switch (level) {
1869                         case 5:
1870                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1871                         break;
1872
1873                         case 8:
1874                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1875                         break;
1876
1877                         case 10:
1878                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1879                         break;
1880
1881                         default:
1882                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1883                 }
1884         }
1885         return NDR_ERR_SUCCESS;
1886 }
1887
1888 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesRequest *r)
1889 {
1890         int level;
1891         level = ndr_print_get_switch_value(ndr, r);
1892         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesRequest");
1893         switch (level) {
1894                 case 5:
1895                         ndr_print_drsuapi_DsGetNCChangesRequest5(ndr, "req5", &r->req5);
1896                 break;
1897
1898                 case 8:
1899                         ndr_print_drsuapi_DsGetNCChangesRequest8(ndr, "req8", &r->req8);
1900                 break;
1901
1902                 case 10:
1903                         ndr_print_drsuapi_DsGetNCChangesRequest10(ndr, "req10", &r->req10);
1904                 break;
1905
1906                 default:
1907                         ndr_print_bad_level(ndr, name, level);
1908         }
1909 }
1910
1911 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2 *r)
1912 {
1913         if (ndr_flags & NDR_SCALARS) {
1914                 NDR_CHECK(ndr_push_align(ndr, 8));
1915                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1916                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
1917                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
1918                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1919         }
1920         if (ndr_flags & NDR_BUFFERS) {
1921         }
1922         return NDR_ERR_SUCCESS;
1923 }
1924
1925 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2 *r)
1926 {
1927         if (ndr_flags & NDR_SCALARS) {
1928                 NDR_CHECK(ndr_pull_align(ndr, 8));
1929                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1930                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
1931                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
1932                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1933         }
1934         if (ndr_flags & NDR_BUFFERS) {
1935         }
1936         return NDR_ERR_SUCCESS;
1937 }
1938
1939 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2 *r)
1940 {
1941         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2");
1942         ndr->depth++;
1943         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1944         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
1945         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
1946         ndr->depth--;
1947 }
1948
1949 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1950 {
1951         uint32_t cntr_cursors_0;
1952         if (ndr_flags & NDR_SCALARS) {
1953                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1954                 NDR_CHECK(ndr_push_align(ndr, 8));
1955                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
1956                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1957                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1958                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1959                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1960                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1961                 }
1962                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1963         }
1964         if (ndr_flags & NDR_BUFFERS) {
1965         }
1966         return NDR_ERR_SUCCESS;
1967 }
1968
1969 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2CtrEx *r)
1970 {
1971         uint32_t cntr_cursors_0;
1972         TALLOC_CTX *_mem_save_cursors_0;
1973         if (ndr_flags & NDR_SCALARS) {
1974                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
1975                 NDR_CHECK(ndr_pull_align(ndr, 8));
1976                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1977                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1978                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1979                 if (r->count > 0x100000) {
1980                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1981                 }
1982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1983                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
1984                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
1985                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
1986                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1987                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1988                 }
1989                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
1990                 if (r->cursors) {
1991                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
1992                 }
1993                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1994         }
1995         if (ndr_flags & NDR_BUFFERS) {
1996         }
1997         return NDR_ERR_SUCCESS;
1998 }
1999
2000 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2CtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2CtrEx *r)
2001 {
2002         uint32_t cntr_cursors_0;
2003         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2CtrEx");
2004         ndr->depth++;
2005         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
2006         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
2007         ndr_print_uint32(ndr, "count", r->count);
2008         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
2009         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
2010         ndr->depth++;
2011         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
2012                 char *idx_0=NULL;
2013                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
2014                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
2015                         free(idx_0);
2016                 }
2017         }
2018         ndr->depth--;
2019         ndr->depth--;
2020 }
2021
2022 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValue(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValue *r)
2023 {
2024         if (ndr_flags & NDR_SCALARS) {
2025                 NDR_CHECK(ndr_push_align(ndr, 5));
2026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->blob, 0)));
2027                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->blob));
2028                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2029         }
2030         if (ndr_flags & NDR_BUFFERS) {
2031                 if (r->blob) {
2032                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->blob));
2033                 }
2034         }
2035         return NDR_ERR_SUCCESS;
2036 }
2037
2038 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValue *r)
2039 {
2040         uint32_t _ptr_blob;
2041         TALLOC_CTX *_mem_save_blob_0;
2042         if (ndr_flags & NDR_SCALARS) {
2043                 NDR_CHECK(ndr_pull_align(ndr, 5));
2044                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2045                 if (r->__ndr_size > 10485760) {
2046                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2047                 }
2048                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_blob));
2049                 if (_ptr_blob) {
2050                         NDR_PULL_ALLOC(ndr, r->blob);
2051                 } else {
2052                         r->blob = NULL;
2053                 }
2054                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2055         }
2056         if (ndr_flags & NDR_BUFFERS) {
2057                 if (r->blob) {
2058                         _mem_save_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
2059                         NDR_PULL_SET_MEM_CTX(ndr, r->blob, 0);
2060                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->blob));
2061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_blob_0, 0);
2062                 }
2063         }
2064         return NDR_ERR_SUCCESS;
2065 }
2066
2067 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValue(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValue *r)
2068 {
2069         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
2070         ndr->depth++;
2071         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_DATA_BLOB(0, r->blob, 0):r->__ndr_size);
2072         ndr_print_ptr(ndr, "blob", r->blob);
2073         ndr->depth++;
2074         if (r->blob) {
2075                 ndr_print_DATA_BLOB(ndr, "blob", *r->blob);
2076         }
2077         ndr->depth--;
2078         ndr->depth--;
2079 }
2080
2081 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValueCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValueCtr *r)
2082 {
2083         uint32_t cntr_values_1;
2084         if (ndr_flags & NDR_SCALARS) {
2085                 NDR_CHECK(ndr_push_align(ndr, 5));
2086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
2087                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->values));
2088                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2089         }
2090         if (ndr_flags & NDR_BUFFERS) {
2091                 if (r->values) {
2092                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_values));
2093                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2094                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2095                         }
2096                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2097                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2098                         }
2099                 }
2100         }
2101         return NDR_ERR_SUCCESS;
2102 }
2103
2104 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValueCtr *r)
2105 {
2106         uint32_t _ptr_values;
2107         uint32_t cntr_values_1;
2108         TALLOC_CTX *_mem_save_values_0;
2109         TALLOC_CTX *_mem_save_values_1;
2110         if (ndr_flags & NDR_SCALARS) {
2111                 NDR_CHECK(ndr_pull_align(ndr, 5));
2112                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_values));
2113                 if (r->num_values > 10485760) {
2114                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2115                 }
2116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_values));
2117                 if (_ptr_values) {
2118                         NDR_PULL_ALLOC(ndr, r->values);
2119                 } else {
2120                         r->values = NULL;
2121                 }
2122                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2123         }
2124         if (ndr_flags & NDR_BUFFERS) {
2125                 if (r->values) {
2126                         _mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
2127                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2128                         NDR_CHECK(ndr_pull_array_size(ndr, &r->values));
2129                         NDR_PULL_ALLOC_N(ndr, r->values, ndr_get_array_size(ndr, &r->values));
2130                         _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
2131                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2132                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2133                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2134                         }
2135                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2136                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2137                         }
2138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
2139                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_0, 0);
2140                 }
2141                 if (r->values) {
2142                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->values, r->num_values));
2143                 }
2144         }
2145         return NDR_ERR_SUCCESS;
2146 }
2147
2148 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValueCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValueCtr *r)
2149 {
2150         uint32_t cntr_values_1;
2151         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValueCtr");
2152         ndr->depth++;
2153         ndr_print_uint32(ndr, "num_values", r->num_values);
2154         ndr_print_ptr(ndr, "values", r->values);
2155         ndr->depth++;
2156         if (r->values) {
2157                 ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->num_values);
2158                 ndr->depth++;
2159                 for (cntr_values_1=0;cntr_values_1<r->num_values;cntr_values_1++) {
2160                         char *idx_1=NULL;
2161                         if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
2162                                 ndr_print_drsuapi_DsAttributeValue(ndr, "values", &r->values[cntr_values_1]);
2163                                 free(idx_1);
2164                         }
2165                 }
2166                 ndr->depth--;
2167         }
2168         ndr->depth--;
2169         ndr->depth--;
2170 }
2171
2172 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2173 {
2174         if (ndr_flags & NDR_SCALARS) {
2175                 NDR_CHECK(ndr_push_align(ndr, 4));
2176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
2177                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2178                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2179                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2181                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2182                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2183         }
2184         if (ndr_flags & NDR_BUFFERS) {
2185                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2186         }
2187         return NDR_ERR_SUCCESS;
2188 }
2189
2190 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3 *r)
2191 {
2192         if (ndr_flags & NDR_SCALARS) {
2193                 NDR_CHECK(ndr_pull_align(ndr, 4));
2194                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2196                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2197                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2198                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2199                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2200                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2201         }
2202         if (ndr_flags & NDR_BUFFERS) {
2203                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2204         }
2205         return NDR_ERR_SUCCESS;
2206 }
2207
2208 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2209 {
2210         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3");
2211         ndr->depth++;
2212         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);
2213         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);
2214         ndr_print_GUID(ndr, "guid", &r->guid);
2215         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2216         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2217         ndr_print_string(ndr, "dn", r->dn);
2218         ndr->depth--;
2219 }
2220
2221 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3(const struct drsuapi_DsReplicaObjectIdentifier3 *r, struct smb_iconv_convenience *ic, int flags)
2222 {
2223         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3, ic);
2224 }
2225
2226 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2227 {
2228         if (ndr_flags & NDR_SCALARS) {
2229                 NDR_CHECK(ndr_push_align(ndr, 4));
2230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
2231                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2232                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2233                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2234                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2235                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2236                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->binary.length + 4));
2237                 {
2238                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2240                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
2241                         ndr->flags = _flags_save_DATA_BLOB;
2242                 }
2243                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2244         }
2245         if (ndr_flags & NDR_BUFFERS) {
2246                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2247         }
2248         return NDR_ERR_SUCCESS;
2249 }
2250
2251 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2252 {
2253         if (ndr_flags & NDR_SCALARS) {
2254                 NDR_CHECK(ndr_pull_align(ndr, 4));
2255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2257                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2258                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2260                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2261                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
2262                 {
2263                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2264                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2265                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
2266                         ndr->flags = _flags_save_DATA_BLOB;
2267                 }
2268                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2269         }
2270         if (ndr_flags & NDR_BUFFERS) {
2271                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2272         }
2273         return NDR_ERR_SUCCESS;
2274 }
2275
2276 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2277 {
2278         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3Binary");
2279         ndr->depth++;
2280         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);
2281         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);
2282         ndr_print_GUID(ndr, "guid", &r->guid);
2283         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2284         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2285         ndr_print_string(ndr, "dn", r->dn);
2286         ndr_print_uint32(ndr, "__ndr_size_binary", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->binary.length + 4:r->__ndr_size_binary);
2287         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
2288         ndr->depth--;
2289 }
2290
2291 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(const struct drsuapi_DsReplicaObjectIdentifier3Binary *r, struct smb_iconv_convenience *ic, int flags)
2292 {
2293         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary, ic);
2294 }
2295
2296 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttribute *r)
2297 {
2298         if (ndr_flags & NDR_SCALARS) {
2299                 NDR_CHECK(ndr_push_align(ndr, 5));
2300                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2301                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2302                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2303         }
2304         if (ndr_flags & NDR_BUFFERS) {
2305                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2306         }
2307         return NDR_ERR_SUCCESS;
2308 }
2309
2310 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttribute *r)
2311 {
2312         if (ndr_flags & NDR_SCALARS) {
2313                 NDR_CHECK(ndr_pull_align(ndr, 5));
2314                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2315                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2316                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2317         }
2318         if (ndr_flags & NDR_BUFFERS) {
2319                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2320         }
2321         return NDR_ERR_SUCCESS;
2322 }
2323
2324 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttribute *r)
2325 {
2326         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttribute");
2327         ndr->depth++;
2328         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2329         ndr_print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr);
2330         ndr->depth--;
2331 }
2332
2333 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttributeCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttributeCtr *r)
2334 {
2335         uint32_t cntr_attributes_1;
2336         if (ndr_flags & NDR_SCALARS) {
2337                 NDR_CHECK(ndr_push_align(ndr, 5));
2338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2339                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
2340                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2341         }
2342         if (ndr_flags & NDR_BUFFERS) {
2343                 if (r->attributes) {
2344                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attributes));
2345                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2346                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2347                         }
2348                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2349                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2350                         }
2351                 }
2352         }
2353         return NDR_ERR_SUCCESS;
2354 }
2355
2356 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttributeCtr *r)
2357 {
2358         uint32_t _ptr_attributes;
2359         uint32_t cntr_attributes_1;
2360         TALLOC_CTX *_mem_save_attributes_0;
2361         TALLOC_CTX *_mem_save_attributes_1;
2362         if (ndr_flags & NDR_SCALARS) {
2363                 NDR_CHECK(ndr_pull_align(ndr, 5));
2364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attributes));
2365                 if (r->num_attributes > 1048576) {
2366                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2367                 }
2368                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
2369                 if (_ptr_attributes) {
2370                         NDR_PULL_ALLOC(ndr, r->attributes);
2371                 } else {
2372                         r->attributes = NULL;
2373                 }
2374                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2375         }
2376         if (ndr_flags & NDR_BUFFERS) {
2377                 if (r->attributes) {
2378                         _mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2379                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2380                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
2381                         NDR_PULL_ALLOC_N(ndr, r->attributes, ndr_get_array_size(ndr, &r->attributes));
2382                         _mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2383                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2384                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2385                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2386                         }
2387                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2388                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2389                         }
2390                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
2391                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);
2392                 }
2393                 if (r->attributes) {
2394                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->num_attributes));
2395                 }
2396         }
2397         return NDR_ERR_SUCCESS;
2398 }
2399
2400 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttributeCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttributeCtr *r)
2401 {
2402         uint32_t cntr_attributes_1;
2403         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttributeCtr");
2404         ndr->depth++;
2405         ndr_print_uint32(ndr, "num_attributes", r->num_attributes);
2406         ndr_print_ptr(ndr, "attributes", r->attributes);
2407         ndr->depth++;
2408         if (r->attributes) {
2409                 ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->num_attributes);
2410                 ndr->depth++;
2411                 for (cntr_attributes_1=0;cntr_attributes_1<r->num_attributes;cntr_attributes_1++) {
2412                         char *idx_1=NULL;
2413                         if (asprintf(&idx_1, "[%d]", cntr_attributes_1) != -1) {
2414                                 ndr_print_drsuapi_DsReplicaAttribute(ndr, "attributes", &r->attributes[cntr_attributes_1]);
2415                                 free(idx_1);
2416                         }
2417                 }
2418                 ndr->depth--;
2419         }
2420         ndr->depth--;
2421         ndr->depth--;
2422 }
2423
2424 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2425 {
2426         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2427         return NDR_ERR_SUCCESS;
2428 }
2429
2430 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2431 {
2432         uint32_t v;
2433         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2434         *r = v;
2435         return NDR_ERR_SUCCESS;
2436 }
2437
2438 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2439 {
2440         ndr_print_uint32(ndr, name, r);
2441         ndr->depth++;
2442         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER", DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER, r);
2443         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC", DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC, r);
2444         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY", DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY, r);
2445         ndr->depth--;
2446 }
2447
2448 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObject(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObject *r)
2449 {
2450         if (ndr_flags & NDR_SCALARS) {
2451                 NDR_CHECK(ndr_push_align(ndr, 5));
2452                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2453                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, r->flags));
2454                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2455                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2456         }
2457         if (ndr_flags & NDR_BUFFERS) {
2458                 if (r->identifier) {
2459                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2460                 }
2461                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2462         }
2463         return NDR_ERR_SUCCESS;
2464 }
2465
2466 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObject *r)
2467 {
2468         uint32_t _ptr_identifier;
2469         TALLOC_CTX *_mem_save_identifier_0;
2470         if (ndr_flags & NDR_SCALARS) {
2471                 NDR_CHECK(ndr_pull_align(ndr, 5));
2472                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2473                 if (_ptr_identifier) {
2474                         NDR_PULL_ALLOC(ndr, r->identifier);
2475                 } else {
2476                         r->identifier = NULL;
2477                 }
2478                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, &r->flags));
2479                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2480                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2481         }
2482         if (ndr_flags & NDR_BUFFERS) {
2483                 if (r->identifier) {
2484                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2485                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2486                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2487                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2488                 }
2489                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2490         }
2491         return NDR_ERR_SUCCESS;
2492 }
2493
2494 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObject(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObject *r)
2495 {
2496         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObject");
2497         ndr->depth++;
2498         ndr_print_ptr(ndr, "identifier", r->identifier);
2499         ndr->depth++;
2500         if (r->identifier) {
2501                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2502         }
2503         ndr->depth--;
2504         ndr_print_drsuapi_DsReplicaObjectFlags(ndr, "flags", r->flags);
2505         ndr_print_drsuapi_DsReplicaAttributeCtr(ndr, "attribute_ctr", &r->attribute_ctr);
2506         ndr->depth--;
2507 }
2508
2509 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaData *r)
2510 {
2511         if (ndr_flags & NDR_SCALARS) {
2512                 NDR_CHECK(ndr_push_align(ndr, 8));
2513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2514                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
2515                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2516                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
2517                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2518         }
2519         if (ndr_flags & NDR_BUFFERS) {
2520         }
2521         return NDR_ERR_SUCCESS;
2522 }
2523
2524 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaData *r)
2525 {
2526         if (ndr_flags & NDR_SCALARS) {
2527                 NDR_CHECK(ndr_pull_align(ndr, 8));
2528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2529                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
2530                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2531                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
2532                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2533         }
2534         if (ndr_flags & NDR_BUFFERS) {
2535         }
2536         return NDR_ERR_SUCCESS;
2537 }
2538
2539 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaData *r)
2540 {
2541         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaData");
2542         ndr->depth++;
2543         ndr_print_uint32(ndr, "version", r->version);
2544         ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
2545         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
2546         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
2547         ndr->depth--;
2548 }
2549
2550 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaDataCtr *r)
2551 {
2552         uint32_t cntr_meta_data_0;
2553         if (ndr_flags & NDR_SCALARS) {
2554                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
2555                 NDR_CHECK(ndr_push_align(ndr, 8));
2556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2557                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2558                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2559                 }
2560                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2561         }
2562         if (ndr_flags & NDR_BUFFERS) {
2563         }
2564         return NDR_ERR_SUCCESS;
2565 }
2566
2567 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaDataCtr *r)
2568 {
2569         uint32_t cntr_meta_data_0;
2570         TALLOC_CTX *_mem_save_meta_data_0;
2571         if (ndr_flags & NDR_SCALARS) {
2572                 NDR_CHECK(ndr_pull_array_size(ndr, &r->meta_data));
2573                 NDR_CHECK(ndr_pull_align(ndr, 8));
2574                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2575                 if (r->count > 1048576) {
2576                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2577                 }
2578                 NDR_PULL_ALLOC_N(ndr, r->meta_data, ndr_get_array_size(ndr, &r->meta_data));
2579                 _mem_save_meta_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2580                 NDR_PULL_SET_MEM_CTX(ndr, r->meta_data, 0);
2581                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2582                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2583                 }
2584                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_0, 0);
2585                 if (r->meta_data) {
2586                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->meta_data, r->count));
2587                 }
2588                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2589         }
2590         if (ndr_flags & NDR_BUFFERS) {
2591         }
2592         return NDR_ERR_SUCCESS;
2593 }
2594
2595 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaDataCtr *r)
2596 {
2597         uint32_t cntr_meta_data_0;
2598         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaDataCtr");
2599         ndr->depth++;
2600         ndr_print_uint32(ndr, "count", r->count);
2601         ndr->print(ndr, "%s: ARRAY(%d)", "meta_data", (int)r->count);
2602         ndr->depth++;
2603         for (cntr_meta_data_0=0;cntr_meta_data_0<r->count;cntr_meta_data_0++) {
2604                 char *idx_0=NULL;
2605                 if (asprintf(&idx_0, "[%d]", cntr_meta_data_0) != -1) {
2606                         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data[cntr_meta_data_0]);
2607                         free(idx_0);
2608                 }
2609         }
2610         ndr->depth--;
2611         ndr->depth--;
2612 }
2613
2614 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItemEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItemEx *r)
2615 {
2616         if (ndr_flags & NDR_SCALARS) {
2617                 NDR_CHECK(ndr_push_align(ndr, 5));
2618                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
2619                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2620                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_nc_prefix));
2621                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parent_object_guid));
2622                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->meta_data_ctr));
2623                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2624         }
2625         if (ndr_flags & NDR_BUFFERS) {
2626                 if (r->next_object) {
2627                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2628                 }
2629                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2630                 if (r->parent_object_guid) {
2631                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2632                 }
2633                 if (r->meta_data_ctr) {
2634                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2635                 }
2636         }
2637         return NDR_ERR_SUCCESS;
2638 }
2639
2640 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItemEx *r)
2641 {
2642         uint32_t _ptr_next_object;
2643         TALLOC_CTX *_mem_save_next_object_0;
2644         uint32_t _ptr_parent_object_guid;
2645         TALLOC_CTX *_mem_save_parent_object_guid_0;
2646         uint32_t _ptr_meta_data_ctr;
2647         TALLOC_CTX *_mem_save_meta_data_ctr_0;
2648         if (ndr_flags & NDR_SCALARS) {
2649                 NDR_CHECK(ndr_pull_align(ndr, 5));
2650                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
2651                 if (_ptr_next_object) {
2652                         NDR_PULL_ALLOC(ndr, r->next_object);
2653                 } else {
2654                         r->next_object = NULL;
2655                 }
2656                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2657                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_nc_prefix));
2658                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parent_object_guid));
2659                 if (_ptr_parent_object_guid) {
2660                         NDR_PULL_ALLOC(ndr, r->parent_object_guid);
2661                 } else {
2662                         r->parent_object_guid = NULL;
2663                 }
2664                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_meta_data_ctr));
2665                 if (_ptr_meta_data_ctr) {
2666                         NDR_PULL_ALLOC(ndr, r->meta_data_ctr);
2667                 } else {
2668                         r->meta_data_ctr = NULL;
2669                 }
2670                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2671         }
2672         if (ndr_flags & NDR_BUFFERS) {
2673                 if (r->next_object) {
2674                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2675                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
2676                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2677                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
2678                 }
2679                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2680                 if (r->parent_object_guid) {
2681                         _mem_save_parent_object_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2682                         NDR_PULL_SET_MEM_CTX(ndr, r->parent_object_guid, 0);
2683                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2684                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_object_guid_0, 0);
2685                 }
2686                 if (r->meta_data_ctr) {
2687                         _mem_save_meta_data_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2688                         NDR_PULL_SET_MEM_CTX(ndr, r->meta_data_ctr, 0);
2689                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2690                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_ctr_0, 0);
2691                 }
2692         }
2693         return NDR_ERR_SUCCESS;
2694 }
2695
2696 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1 *r)
2697 {
2698         if (ndr_flags & NDR_SCALARS) {
2699                 NDR_CHECK(ndr_push_align(ndr, 8));
2700                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2701                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2702                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2703                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2704                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2705                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2706                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2707                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2709                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55));
2710                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2712                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2713         }
2714         if (ndr_flags & NDR_BUFFERS) {
2715                 if (r->naming_context) {
2716                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2717                 }
2718                 if (r->uptodateness_vector) {
2719                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2720                 }
2721                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2722                 if (r->first_object) {
2723                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2724                 }
2725         }
2726         return NDR_ERR_SUCCESS;
2727 }
2728
2729 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1 *r)
2730 {
2731         uint32_t _ptr_naming_context;
2732         TALLOC_CTX *_mem_save_naming_context_0;
2733         uint32_t _ptr_uptodateness_vector;
2734         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2735         uint32_t _ptr_first_object;
2736         TALLOC_CTX *_mem_save_first_object_0;
2737         if (ndr_flags & NDR_SCALARS) {
2738                 NDR_CHECK(ndr_pull_align(ndr, 8));
2739                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2740                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2741                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2742                 if (_ptr_naming_context) {
2743                         NDR_PULL_ALLOC(ndr, r->naming_context);
2744                 } else {
2745                         r->naming_context = NULL;
2746                 }
2747                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2748                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2749                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2750                 if (_ptr_uptodateness_vector) {
2751                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2752                 } else {
2753                         r->uptodateness_vector = NULL;
2754                 }
2755                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2756                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2758                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2759                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2760                 if (_ptr_first_object) {
2761                         NDR_PULL_ALLOC(ndr, r->first_object);
2762                 } else {
2763                         r->first_object = NULL;
2764                 }
2765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2766                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2767         }
2768         if (ndr_flags & NDR_BUFFERS) {
2769                 if (r->naming_context) {
2770                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2771                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2772                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2773                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2774                 }
2775                 if (r->uptodateness_vector) {
2776                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2777                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2778                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2779                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2780                 }
2781                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2782                 if (r->first_object) {
2783                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2784                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2785                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2786                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2787                 }
2788         }
2789         return NDR_ERR_SUCCESS;
2790 }
2791
2792 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1 *r)
2793 {
2794         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1");
2795         ndr->depth++;
2796         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2797         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2798         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2799         ndr->depth++;
2800         if (r->naming_context) {
2801                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2802         }
2803         ndr->depth--;
2804         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2805         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2806         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2807         ndr->depth++;
2808         if (r->uptodateness_vector) {
2809                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2810         }
2811         ndr->depth--;
2812         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2813         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2814         ndr_print_uint32(ndr, "object_count", r->object_count);
2815         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);
2816         ndr_print_ptr(ndr, "first_object", r->first_object);
2817         ndr->depth++;
2818         if (r->first_object) {
2819                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2820         }
2821         ndr->depth--;
2822         ndr_print_uint32(ndr, "more_data", r->more_data);
2823         ndr->depth--;
2824 }
2825
2826 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr1(const struct drsuapi_DsGetNCChangesCtr1 *r, struct smb_iconv_convenience *ic, int flags)
2827 {
2828         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr1, ic);
2829 }
2830
2831 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsLinkedAttributeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2832 {
2833         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2834         return NDR_ERR_SUCCESS;
2835 }
2836
2837 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsLinkedAttributeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2838 {
2839         uint32_t v;
2840         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2841         *r = v;
2842         return NDR_ERR_SUCCESS;
2843 }
2844
2845 _PUBLIC_ void ndr_print_drsuapi_DsLinkedAttributeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2846 {
2847         ndr_print_uint32(ndr, name, r);
2848         ndr->depth++;
2849         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE", DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE, r);
2850         ndr->depth--;
2851 }
2852
2853 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaLinkedAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaLinkedAttribute *r)
2854 {
2855         if (ndr_flags & NDR_SCALARS) {
2856                 NDR_CHECK(ndr_push_align(ndr, 8));
2857                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2858                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2859                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2860                 NDR_CHECK(ndr_push_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, r->flags));
2861                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_add_time));
2862                 NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2863                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2864         }
2865         if (ndr_flags & NDR_BUFFERS) {
2866                 if (r->identifier) {
2867                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2868                 }
2869                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2870         }
2871         return NDR_ERR_SUCCESS;
2872 }
2873
2874 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaLinkedAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaLinkedAttribute *r)
2875 {
2876         uint32_t _ptr_identifier;
2877         TALLOC_CTX *_mem_save_identifier_0;
2878         if (ndr_flags & NDR_SCALARS) {
2879                 NDR_CHECK(ndr_pull_align(ndr, 8));
2880                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2881                 if (_ptr_identifier) {
2882                         NDR_PULL_ALLOC(ndr, r->identifier);
2883                 } else {
2884                         r->identifier = NULL;
2885                 }
2886                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2887                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2888                 NDR_CHECK(ndr_pull_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, &r->flags));
2889                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_add_time));
2890                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2891                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2892         }
2893         if (ndr_flags & NDR_BUFFERS) {
2894                 if (r->identifier) {
2895                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2896                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2897                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2898                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2899                 }
2900                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2901         }
2902         return NDR_ERR_SUCCESS;
2903 }
2904
2905 _PUBLIC_ void ndr_print_drsuapi_DsReplicaLinkedAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaLinkedAttribute *r)
2906 {
2907         ndr_print_struct(ndr, name, "drsuapi_DsReplicaLinkedAttribute");
2908         ndr->depth++;
2909         ndr_print_ptr(ndr, "identifier", r->identifier);
2910         ndr->depth++;
2911         if (r->identifier) {
2912                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2913         }
2914         ndr->depth--;
2915         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2916         ndr_print_drsuapi_DsAttributeValue(ndr, "value", &r->value);
2917         ndr_print_drsuapi_DsLinkedAttributeFlags(ndr, "flags", r->flags);
2918         ndr_print_NTTIME_1sec(ndr, "originating_add_time", r->originating_add_time);
2919         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data);
2920         ndr->depth--;
2921 }
2922
2923 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6 *r)
2924 {
2925         uint32_t cntr_linked_attributes_1;
2926         if (ndr_flags & NDR_SCALARS) {
2927                 NDR_CHECK(ndr_push_align(ndr, 8));
2928                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2929                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2930                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2931                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2932                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2933                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2934                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2935                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2936                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2937                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55));
2938                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_object_count));
2941                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_linked_attributes_count));
2942                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linked_attributes));
2944                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->drs_error));
2945                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2946         }
2947         if (ndr_flags & NDR_BUFFERS) {
2948                 if (r->naming_context) {
2949                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2950                 }
2951                 if (r->uptodateness_vector) {
2952                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2953                 }
2954                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2955                 if (r->first_object) {
2956                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2957                 }
2958                 if (r->linked_attributes) {
2959                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->linked_attributes_count));
2960                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2961                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2962                         }
2963                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2964                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
2965                         }
2966                 }
2967         }
2968         return NDR_ERR_SUCCESS;
2969 }
2970
2971 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6 *r)
2972 {
2973         uint32_t _ptr_naming_context;
2974         TALLOC_CTX *_mem_save_naming_context_0;
2975         uint32_t _ptr_uptodateness_vector;
2976         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2977         uint32_t _ptr_first_object;
2978         TALLOC_CTX *_mem_save_first_object_0;
2979         uint32_t _ptr_linked_attributes;
2980         uint32_t cntr_linked_attributes_1;
2981         TALLOC_CTX *_mem_save_linked_attributes_0;
2982         TALLOC_CTX *_mem_save_linked_attributes_1;
2983         if (ndr_flags & NDR_SCALARS) {
2984                 NDR_CHECK(ndr_pull_align(ndr, 8));
2985                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2986                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2987                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2988                 if (_ptr_naming_context) {
2989                         NDR_PULL_ALLOC(ndr, r->naming_context);
2990                 } else {
2991                         r->naming_context = NULL;
2992                 }
2993                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2994                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2995                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2996                 if (_ptr_uptodateness_vector) {
2997                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2998                 } else {
2999                         r->uptodateness_vector = NULL;
3000                 }
3001                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
3002                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
3003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
3004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
3005                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
3006                 if (_ptr_first_object) {
3007                         NDR_PULL_ALLOC(ndr, r->first_object);
3008                 } else {
3009                         r->first_object = NULL;
3010                 }
3011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
3012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_object_count));
3013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_linked_attributes_count));
3014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linked_attributes_count));
3015                 if (r->linked_attributes_count > 1048576) {
3016                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3017                 }
3018                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linked_attributes));
3019                 if (_ptr_linked_attributes) {
3020                         NDR_PULL_ALLOC(ndr, r->linked_attributes);
3021                 } else {
3022                         r->linked_attributes = NULL;
3023                 }
3024                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->drs_error));
3025                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
3026         }
3027         if (ndr_flags & NDR_BUFFERS) {
3028                 if (r->naming_context) {
3029                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3030                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3031                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3032                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3033                 }
3034                 if (r->uptodateness_vector) {
3035                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
3036                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
3037                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
3038                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
3039                 }
3040                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
3041                 if (r->first_object) {
3042                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
3043                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
3044                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
3045                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
3046                 }
3047                 if (r->linked_attributes) {
3048                         _mem_save_linked_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
3049                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3050                         NDR_CHECK(ndr_pull_array_size(ndr, &r->linked_attributes));
3051                         NDR_PULL_ALLOC_N(ndr, r->linked_attributes, ndr_get_array_size(ndr, &r->linked_attributes));
3052                         _mem_save_linked_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
3053                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3054                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3055                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
3056                         }
3057                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3058                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
3059                         }
3060                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_1, 0);
3061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_0, 0);
3062                 }
3063                 if (r->linked_attributes) {
3064                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->linked_attributes, r->linked_attributes_count));
3065                 }
3066         }
3067         return NDR_ERR_SUCCESS;
3068 }
3069
3070 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6 *r)
3071 {
3072         uint32_t cntr_linked_attributes_1;
3073         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6");
3074         ndr->depth++;
3075         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
3076         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
3077         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3078         ndr->depth++;
3079         if (r->naming_context) {
3080                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3081         }
3082         ndr->depth--;
3083         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
3084         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
3085         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
3086         ndr->depth++;
3087         if (r->uptodateness_vector) {
3088                 ndr_print_drsuapi_DsReplicaCursor2CtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
3089         }
3090         ndr->depth--;
3091         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
3092         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
3093         ndr_print_uint32(ndr, "object_count", r->object_count);
3094         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);
3095         ndr_print_ptr(ndr, "first_object", r->first_object);
3096         ndr->depth++;
3097         if (r->first_object) {
3098                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
3099         }
3100         ndr->depth--;
3101         ndr_print_uint32(ndr, "more_data", r->more_data);
3102         ndr_print_uint32(ndr, "nc_object_count", r->nc_object_count);
3103         ndr_print_uint32(ndr, "nc_linked_attributes_count", r->nc_linked_attributes_count);
3104         ndr_print_uint32(ndr, "linked_attributes_count", r->linked_attributes_count);
3105         ndr_print_ptr(ndr, "linked_attributes", r->linked_attributes);
3106         ndr->depth++;
3107         if (r->linked_attributes) {
3108                 ndr->print(ndr, "%s: ARRAY(%d)", "linked_attributes", (int)r->linked_attributes_count);
3109                 ndr->depth++;
3110                 for (cntr_linked_attributes_1=0;cntr_linked_attributes_1<r->linked_attributes_count;cntr_linked_attributes_1++) {
3111                         char *idx_1=NULL;
3112                         if (asprintf(&idx_1, "[%d]", cntr_linked_attributes_1) != -1) {
3113                                 ndr_print_drsuapi_DsReplicaLinkedAttribute(ndr, "linked_attributes", &r->linked_attributes[cntr_linked_attributes_1]);
3114                                 free(idx_1);
3115                         }
3116                 }
3117                 ndr->depth--;
3118         }
3119         ndr->depth--;
3120         ndr_print_WERROR(ndr, "drs_error", r->drs_error);
3121         ndr->depth--;
3122 }
3123
3124 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr6(const struct drsuapi_DsGetNCChangesCtr6 *r, struct smb_iconv_convenience *ic, int flags)
3125 {
3126         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr6, ic);
3127 }
3128
3129 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3130 {
3131         if (ndr_flags & NDR_SCALARS) {
3132                 NDR_CHECK(ndr_push_align(ndr, 1));
3133                 {
3134                         struct ndr_push *_ndr_ctr1;
3135                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3136                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3137                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3138                 }
3139                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3140         }
3141         if (ndr_flags & NDR_BUFFERS) {
3142         }
3143         return NDR_ERR_SUCCESS;
3144 }
3145
3146 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1TS *r)
3147 {
3148         if (ndr_flags & NDR_SCALARS) {
3149                 NDR_CHECK(ndr_pull_align(ndr, 1));
3150                 {
3151                         struct ndr_pull *_ndr_ctr1;
3152                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3153                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3154                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3155                 }
3156                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3157         }
3158         if (ndr_flags & NDR_BUFFERS) {
3159         }
3160         return NDR_ERR_SUCCESS;
3161 }
3162
3163 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3164 {
3165         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1TS");
3166         ndr->depth++;
3167         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3168         ndr->depth--;
3169 }
3170
3171 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3172 {
3173         if (ndr_flags & NDR_SCALARS) {
3174                 NDR_CHECK(ndr_push_align(ndr, 1));
3175                 {
3176                         struct ndr_push *_ndr_ctr6;
3177                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3178                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3179                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3180                 }
3181                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3182         }
3183         if (ndr_flags & NDR_BUFFERS) {
3184         }
3185         return NDR_ERR_SUCCESS;
3186 }
3187
3188 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6TS *r)
3189 {
3190         if (ndr_flags & NDR_SCALARS) {
3191                 NDR_CHECK(ndr_pull_align(ndr, 1));
3192                 {
3193                         struct ndr_pull *_ndr_ctr6;
3194                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3195                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3196                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3197                 }
3198                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3199         }
3200         if (ndr_flags & NDR_BUFFERS) {
3201         }
3202         return NDR_ERR_SUCCESS;
3203 }
3204
3205 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3206 {
3207         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6TS");
3208         ndr->depth++;
3209         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3210         ndr->depth--;
3211 }
3212
3213 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3214 {
3215         uint32_t _ptr_ts;
3216         TALLOC_CTX *_mem_save_ts_0;
3217         if (ndr_flags & NDR_SCALARS) {
3218                 NDR_CHECK(ndr_pull_align(ndr, 5));
3219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3221                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3222                 if (_ptr_ts) {
3223                         NDR_PULL_ALLOC(ndr, r->ts);
3224                 } else {
3225                         r->ts = NULL;
3226                 }
3227                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3228         }
3229         if (ndr_flags & NDR_BUFFERS) {
3230                 if (r->ts) {
3231                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3232                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3233                         {
3234                                 struct ndr_pull *_ndr_ts;
3235                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3236                                 {
3237                                         struct ndr_pull *_ndr_ts_compressed;
3238                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3239                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3240                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3241                                 }
3242                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3243                         }
3244                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3245                 }
3246         }
3247         return NDR_ERR_SUCCESS;
3248 }
3249
3250 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3251 {
3252         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr1");
3253         ndr->depth++;
3254         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3255         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3256         ndr_print_ptr(ndr, "ts", r->ts);
3257         ndr->depth++;
3258         if (r->ts) {
3259                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3260         }
3261         ndr->depth--;
3262         ndr->depth--;
3263 }
3264
3265 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3266 {
3267         uint32_t _ptr_ts;
3268         TALLOC_CTX *_mem_save_ts_0;
3269         if (ndr_flags & NDR_SCALARS) {
3270                 NDR_CHECK(ndr_pull_align(ndr, 5));
3271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3272                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3273                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3274                 if (_ptr_ts) {
3275                         NDR_PULL_ALLOC(ndr, r->ts);
3276                 } else {
3277                         r->ts = NULL;
3278                 }
3279                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3280         }
3281         if (ndr_flags & NDR_BUFFERS) {
3282                 if (r->ts) {
3283                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3284                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3285                         {
3286                                 struct ndr_pull *_ndr_ts;
3287                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3288                                 {
3289                                         struct ndr_pull *_ndr_ts_compressed;
3290                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3291                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3292                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3293                                 }
3294                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3295                         }
3296                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3297                 }
3298         }
3299         return NDR_ERR_SUCCESS;
3300 }
3301
3302 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3303 {
3304         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr6");
3305         ndr->depth++;
3306         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3307         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3308         ndr_print_ptr(ndr, "ts", r->ts);
3309         ndr->depth++;
3310         if (r->ts) {
3311                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3312         }
3313         ndr->depth--;
3314         ndr->depth--;
3315 }
3316
3317 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3318 {
3319         uint32_t _ptr_ts;
3320         TALLOC_CTX *_mem_save_ts_0;
3321         if (ndr_flags & NDR_SCALARS) {
3322                 NDR_CHECK(ndr_pull_align(ndr, 5));
3323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3325                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3326                 if (_ptr_ts) {
3327                         NDR_PULL_ALLOC(ndr, r->ts);
3328                 } else {
3329                         r->ts = NULL;
3330                 }
3331                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3332         }
3333         if (ndr_flags & NDR_BUFFERS) {
3334                 if (r->ts) {
3335                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3336                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3337                         {
3338                                 struct ndr_pull *_ndr_ts;
3339                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3340                                 {
3341                                         struct ndr_pull *_ndr_ts_compressed;
3342                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3343                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3344                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3345                                 }
3346                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3347                         }
3348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3349                 }
3350         }
3351         return NDR_ERR_SUCCESS;
3352 }
3353
3354 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3355 {
3356         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr1");
3357         ndr->depth++;
3358         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3359         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3360         ndr_print_ptr(ndr, "ts", r->ts);
3361         ndr->depth++;
3362         if (r->ts) {
3363                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3364         }
3365         ndr->depth--;
3366         ndr->depth--;
3367 }
3368
3369 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3370 {
3371         uint32_t _ptr_ts;
3372         TALLOC_CTX *_mem_save_ts_0;
3373         if (ndr_flags & NDR_SCALARS) {
3374                 NDR_CHECK(ndr_pull_align(ndr, 5));
3375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3376                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3377                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3378                 if (_ptr_ts) {
3379                         NDR_PULL_ALLOC(ndr, r->ts);
3380                 } else {
3381                         r->ts = NULL;
3382                 }
3383                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3384         }
3385         if (ndr_flags & NDR_BUFFERS) {
3386                 if (r->ts) {
3387                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3388                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3389                         {
3390                                 struct ndr_pull *_ndr_ts;
3391                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3392                                 {
3393                                         struct ndr_pull *_ndr_ts_compressed;
3394                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3395                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3396                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3397                                 }
3398                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3399                         }
3400                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3401                 }
3402         }
3403         return NDR_ERR_SUCCESS;
3404 }
3405
3406 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3407 {
3408         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr6");
3409         ndr->depth++;
3410         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3411         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3412         ndr_print_ptr(ndr, "ts", r->ts);
3413         ndr->depth++;
3414         if (r->ts) {
3415                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3416         }
3417         ndr->depth--;
3418         ndr->depth--;
3419 }
3420
3421 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressionType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType r)
3422 {
3423         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
3424         return NDR_ERR_SUCCESS;
3425 }
3426
3427 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressionType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType *r)
3428 {
3429         uint16_t v;
3430         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
3431         *r = v;
3432         return NDR_ERR_SUCCESS;
3433 }
3434
3435 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressionType(struct ndr_print *ndr, const char *name, enum drsuapi_DsGetNCChangesCompressionType r)
3436 {
3437         const char *val = NULL;
3438
3439         switch (r) {
3440                 case DRSUAPI_COMPRESSION_TYPE_MSZIP: val = "DRSUAPI_COMPRESSION_TYPE_MSZIP"; break;
3441                 case DRSUAPI_COMPRESSION_TYPE_XPRESS: val = "DRSUAPI_COMPRESSION_TYPE_XPRESS"; break;
3442         }
3443         ndr_print_enum(ndr, name, "ENUM", val, r);
3444 }
3445
3446 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3447 {
3448         {
3449                 uint32_t _flags_save_UNION = ndr->flags;
3450                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3451                 if (ndr_flags & NDR_SCALARS) {
3452                         int level = ndr_push_get_switch_value(ndr, r);
3453                         NDR_CHECK(ndr_push_union_align(ndr, 5));
3454                         switch (level) {
3455                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3456                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3457                                 break; }
3458
3459                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3460                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3461                                 break; }
3462
3463                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3464                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3465                                 break; }
3466
3467                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3468                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3469                                 break; }
3470
3471                                 default:
3472                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3473                         }
3474                 }
3475                 if (ndr_flags & NDR_BUFFERS) {
3476                         int level = ndr_push_get_switch_value(ndr, r);
3477                         switch (level) {
3478                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3479                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3480                                 break;
3481
3482                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3483                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3484                                 break;
3485
3486                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3487                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3488                                 break;
3489
3490                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3491                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3492                                 break;
3493
3494                                 default:
3495                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3496                         }
3497                 }
3498                 ndr->flags = _flags_save_UNION;
3499         }
3500         return NDR_ERR_SUCCESS;
3501 }
3502
3503 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCompressedCtr *r)
3504 {
3505         int level;
3506         {
3507                 uint32_t _flags_save_UNION = ndr->flags;
3508                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3509                 level = ndr_pull_get_switch_value(ndr, r);
3510                 if (ndr_flags & NDR_SCALARS) {
3511                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
3512                         switch (level) {
3513                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3514                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3515                                 break; }
3516
3517                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3518                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3519                                 break; }
3520
3521                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3522                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3523                                 break; }
3524
3525                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3526                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3527                                 break; }
3528
3529                                 default:
3530                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3531                         }
3532                 }
3533                 if (ndr_flags & NDR_BUFFERS) {
3534                         switch (level) {
3535                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3536                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3537                                 break;
3538
3539                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3540                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3541                                 break;
3542
3543                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3544                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3545                                 break;
3546
3547                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3548                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3549                                 break;
3550
3551                                 default:
3552                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3553                         }
3554                 }
3555                 ndr->flags = _flags_save_UNION;
3556         }
3557         return NDR_ERR_SUCCESS;
3558 }
3559
3560 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3561 {
3562         int level;
3563         {
3564                 uint32_t _flags_save_UNION = ndr->flags;
3565                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3566                 level = ndr_print_get_switch_value(ndr, r);
3567                 ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCompressedCtr");
3568                 switch (level) {
3569                         case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3570                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3571                         break;
3572
3573                         case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3574                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, "mszip6", &r->mszip6);
3575                         break;
3576
3577                         case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3578                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, "xpress1", &r->xpress1);
3579                         break;
3580
3581                         case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3582                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, "xpress6", &r->xpress6);
3583                         break;
3584
3585                         default:
3586                                 ndr_print_bad_level(ndr, name, level);
3587                 }
3588                 ndr->flags = _flags_save_UNION;
3589         }
3590 }
3591
3592 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr2 *r)
3593 {
3594         if (ndr_flags & NDR_SCALARS) {
3595                 NDR_CHECK(ndr_push_align(ndr, 5));
3596                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3597                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3598         }
3599         if (ndr_flags & NDR_BUFFERS) {
3600                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3601         }
3602         return NDR_ERR_SUCCESS;
3603 }
3604
3605 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr2 *r)
3606 {
3607         if (ndr_flags & NDR_SCALARS) {
3608                 NDR_CHECK(ndr_pull_align(ndr, 5));
3609                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3610                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3611         }
3612         if (ndr_flags & NDR_BUFFERS) {
3613                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3614         }
3615         return NDR_ERR_SUCCESS;
3616 }
3617
3618 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr2 *r)
3619 {
3620         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr2");
3621         ndr->depth++;
3622         ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3623         ndr->depth--;
3624 }
3625
3626 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr7 *r)
3627 {
3628         if (ndr_flags & NDR_SCALARS) {
3629                 NDR_CHECK(ndr_push_align(ndr, 5));
3630                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
3631                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, r->type));
3632                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3633                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3634                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3635         }
3636         if (ndr_flags & NDR_BUFFERS) {
3637                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3638         }
3639         return NDR_ERR_SUCCESS;
3640 }
3641
3642 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr7 *r)
3643 {
3644         if (ndr_flags & NDR_SCALARS) {
3645                 NDR_CHECK(ndr_pull_align(ndr, 5));
3646                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
3647                 if (r->level < 0 || r->level > 6) {
3648                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3649                 }
3650                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, &r->type));
3651                 if (r->type < 2 || r->type > 3) {
3652                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3653                 }
3654                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3655                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3656                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3657         }
3658         if (ndr_flags & NDR_BUFFERS) {
3659                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3660         }
3661         return NDR_ERR_SUCCESS;
3662 }
3663
3664 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr7(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr7 *r)
3665 {
3666         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr7");
3667         ndr->depth++;
3668         ndr_print_int32(ndr, "level", r->level);
3669         ndr_print_drsuapi_DsGetNCChangesCompressionType(ndr, "type", r->type);
3670         ndr_print_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16));
3671         ndr_print_drsuapi_DsGetNCChangesCompressedCtr(ndr, "ctr", &r->ctr);
3672         ndr->depth--;
3673 }
3674
3675 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCtr *r)
3676 {
3677         if (ndr_flags & NDR_SCALARS) {
3678                 int level = ndr_push_get_switch_value(ndr, r);
3679                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3680                 NDR_CHECK(ndr_push_union_align(ndr, 8));
3681                 switch (level) {
3682                         case 1: {
3683                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3684                         break; }
3685
3686                         case 2: {
3687                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3688                         break; }
3689
3690                         case 6: {
3691                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3692                         break; }
3693
3694                         case 7: {
3695                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3696                         break; }
3697
3698                         default:
3699                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3700                 }
3701         }
3702         if (ndr_flags & NDR_BUFFERS) {
3703                 int level = ndr_push_get_switch_value(ndr, r);
3704                 switch (level) {
3705                         case 1:
3706                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3707                         break;
3708
3709                         case 2:
3710                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3711                         break;
3712
3713                         case 6:
3714                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3715                         break;
3716
3717                         case 7:
3718                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3719                         break;
3720
3721                         default:
3722                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3723                 }
3724         }
3725         return NDR_ERR_SUCCESS;
3726 }
3727
3728 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCtr *r)
3729 {
3730         int level;
3731         int32_t _level;
3732         level = ndr_pull_get_switch_value(ndr, r);
3733         if (ndr_flags & NDR_SCALARS) {
3734                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3735                 if (_level != level) {
3736                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3737                 }
3738                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
3739                 switch (level) {
3740                         case 1: {
3741                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3742                         break; }
3743
3744                         case 2: {
3745                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3746                         break; }
3747
3748                         case 6: {
3749                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3750                         break; }
3751
3752                         case 7: {
3753                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3754                         break; }
3755
3756                         default:
3757                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3758                 }
3759         }
3760         if (ndr_flags & NDR_BUFFERS) {
3761                 switch (level) {
3762                         case 1:
3763                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3764                         break;
3765
3766                         case 2:
3767                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3768                         break;
3769
3770                         case 6:
3771                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3772                         break;
3773
3774                         case 7:
3775                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3776                         break;
3777
3778                         default:
3779                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3780                 }
3781         }
3782         return NDR_ERR_SUCCESS;
3783 }
3784
3785 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCtr *r)
3786 {
3787         int level;
3788         level = ndr_print_get_switch_value(ndr, r);
3789         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCtr");
3790         switch (level) {
3791                 case 1:
3792                         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3793                 break;
3794
3795                 case 2:
3796                         ndr_print_drsuapi_DsGetNCChangesCtr2(ndr, "ctr2", &r->ctr2);
3797                 break;
3798
3799                 case 6:
3800                         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3801                 break;
3802
3803                 case 7:
3804                         ndr_print_drsuapi_DsGetNCChangesCtr7(ndr, "ctr7", &r->ctr7);
3805                 break;
3806
3807                 default:
3808                         ndr_print_bad_level(ndr, name, level);
3809         }
3810 }
3811
3812 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3813 {
3814         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3815         return NDR_ERR_SUCCESS;
3816 }
3817
3818 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3819 {
3820         uint32_t v;
3821         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3822         *r = v;
3823         return NDR_ERR_SUCCESS;
3824 }
3825
3826 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3827 {
3828         ndr_print_uint32(ndr, name, r);
3829         ndr->depth++;
3830         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION, r);
3831         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_GETCHG_CHECK", DRSUAPI_DS_REPLICA_UPDATE_GETCHG_CHECK, r);
3832         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE, r);
3833         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE, r);
3834         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE", DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE, r);
3835         ndr->depth--;
3836 }
3837
3838 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3839 {
3840         if (ndr_flags & NDR_SCALARS) {
3841                 NDR_CHECK(ndr_push_align(ndr, 5));
3842                 if (r->naming_context == NULL) {
3843                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3844                 }
3845                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3846                 if (r->dest_dsa_dns_name == NULL) {
3847                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3848                 }
3849                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3850                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3851                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->options));
3852                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3853         }
3854         if (ndr_flags & NDR_BUFFERS) {
3855                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3856                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3857                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3858                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3859                 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));
3860         }
3861         return NDR_ERR_SUCCESS;
3862 }
3863
3864 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3865 {
3866         uint32_t _ptr_naming_context;
3867         TALLOC_CTX *_mem_save_naming_context_0;
3868         uint32_t _ptr_dest_dsa_dns_name;
3869         if (ndr_flags & NDR_SCALARS) {
3870                 NDR_CHECK(ndr_pull_align(ndr, 5));
3871                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3872                 if (_ptr_naming_context) {
3873                         NDR_PULL_ALLOC(ndr, r->naming_context);
3874                 } else {
3875                         r->naming_context = NULL;
3876                 }
3877                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_dest_dsa_dns_name));
3878                 if (_ptr_dest_dsa_dns_name) {
3879                         NDR_PULL_ALLOC(ndr, r->dest_dsa_dns_name);
3880                 } else {
3881                         r->dest_dsa_dns_name = NULL;
3882                 }
3883                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3884                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->options));
3885                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3886         }
3887         if (ndr_flags & NDR_BUFFERS) {
3888                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3889                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3890                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3891                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3892                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
3893                 NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
3894                 if (ndr_get_array_length(ndr, &r->dest_dsa_dns_name) > ndr_get_array_size(ndr, &r->dest_dsa_dns_name)) {
3895                         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));
3896                 }
3897                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t)));
3898                 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));
3899         }
3900         return NDR_ERR_SUCCESS;
3901 }
3902
3903 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3904 {
3905         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefsRequest1");
3906         ndr->depth++;
3907         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3908         ndr->depth++;
3909         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3910         ndr->depth--;
3911         ndr_print_ptr(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3912         ndr->depth++;
3913         ndr_print_string(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3914         ndr->depth--;
3915         ndr_print_GUID(ndr, "dest_dsa_guid", &r->dest_dsa_guid);
3916         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "options", r->options);
3917         ndr->depth--;
3918 }
3919
3920 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3921 {
3922         if (ndr_flags & NDR_SCALARS) {
3923                 int level = ndr_push_get_switch_value(ndr, r);
3924                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3925                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3926                 switch (level) {
3927                         case 1: {
3928                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3929                         break; }
3930
3931                         default:
3932                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3933                 }
3934         }
3935         if (ndr_flags & NDR_BUFFERS) {
3936                 int level = ndr_push_get_switch_value(ndr, r);
3937                 switch (level) {
3938                         case 1:
3939                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3940                         break;
3941
3942                         default:
3943                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3944                 }
3945         }
3946         return NDR_ERR_SUCCESS;
3947 }
3948
3949 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaUpdateRefsRequest *r)
3950 {
3951         int level;
3952         int32_t _level;
3953         level = ndr_pull_get_switch_value(ndr, r);
3954         if (ndr_flags & NDR_SCALARS) {
3955                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3956                 if (_level != level) {
3957                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3958                 }
3959                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3960                 switch (level) {
3961                         case 1: {
3962                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3963                         break; }
3964
3965                         default:
3966                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3967                 }
3968         }
3969         if (ndr_flags & NDR_BUFFERS) {
3970                 switch (level) {
3971                         case 1:
3972                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3973                         break;
3974
3975                         default:
3976                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3977                 }
3978         }
3979         return NDR_ERR_SUCCESS;
3980 }
3981
3982 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3983 {
3984         int level;
3985         level = ndr_print_get_switch_value(ndr, r);
3986         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaUpdateRefsRequest");
3987         switch (level) {
3988                 case 1:
3989                         ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(ndr, "req1", &r->req1);
3990                 break;
3991
3992                 default:
3993                         ndr_print_bad_level(ndr, name, level);
3994         }
3995 }
3996
3997 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3998 {
3999         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4000         return NDR_ERR_SUCCESS;
4001 }
4002
4003 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4004 {
4005         uint32_t v;
4006         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4007         *r = v;
4008         return NDR_ERR_SUCCESS;
4009 }
4010
4011 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddOptions(struct ndr_print *ndr, const char *name, uint32_t r)
4012 {
4013         ndr_print_uint32(ndr, name, r);
4014         ndr->depth++;
4015         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
4016         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
4017         ndr->depth--;
4018 }
4019
4020 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest1 *r)
4021 {
4022         if (ndr_flags & NDR_SCALARS) {
4023                 NDR_CHECK(ndr_push_align(ndr, 5));
4024                 if (r->naming_context == NULL) {
4025                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4026                 }
4027                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4028                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4029                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4030                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->options));
4031                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4032         }
4033         if (ndr_flags & NDR_BUFFERS) {
4034                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4035                 if (r->source_dsa_address) {
4036                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4037                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4038                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4039                         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));
4040                 }
4041         }
4042         return NDR_ERR_SUCCESS;
4043 }
4044
4045 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest1 *r)
4046 {
4047         uint32_t _ptr_naming_context;
4048         TALLOC_CTX *_mem_save_naming_context_0;
4049         uint32_t _ptr_source_dsa_address;
4050         TALLOC_CTX *_mem_save_source_dsa_address_0;
4051         if (ndr_flags & NDR_SCALARS) {
4052                 NDR_CHECK(ndr_pull_align(ndr, 5));
4053                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4054                 if (_ptr_naming_context) {
4055                         NDR_PULL_ALLOC(ndr, r->naming_context);
4056                 } else {
4057                         r->naming_context = NULL;
4058                 }
4059                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4060                 if (_ptr_source_dsa_address) {
4061                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4062                 } else {
4063                         r->source_dsa_address = NULL;
4064                 }
4065                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4066                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options));
4067                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4068         }
4069         if (ndr_flags & NDR_BUFFERS) {
4070                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4071                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4072                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4073                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4074                 if (r->source_dsa_address) {
4075                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4076                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4077                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4078                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4079                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4080                                 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));
4081                         }
4082                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4083                         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));
4084                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4085                 }
4086         }
4087         return NDR_ERR_SUCCESS;
4088 }
4089
4090 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest1 *r)
4091 {
4092         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest1");
4093         ndr->depth++;
4094         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4095         ndr->depth++;
4096         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4097         ndr->depth--;
4098         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4099         ndr->depth++;
4100         if (r->source_dsa_address) {
4101                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4102         }
4103         ndr->depth--;
4104         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4105         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "options", r->options);
4106         ndr->depth--;
4107 }
4108
4109 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest2 *r)
4110 {
4111         if (ndr_flags & NDR_SCALARS) {
4112                 NDR_CHECK(ndr_push_align(ndr, 5));
4113                 if (r->naming_context == NULL) {
4114                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4115                 }
4116                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4117                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_dn));
4118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_dn));
4119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4120                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4121                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->options));
4122                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4123         }
4124         if (ndr_flags & NDR_BUFFERS) {
4125                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4126                 if (r->source_dsa_dn) {
4127                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4128                 }
4129                 if (r->transport_dn) {
4130                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4131                 }
4132                 if (r->source_dsa_address) {
4133                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4134                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4135                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4136                         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));
4137                 }
4138         }
4139         return NDR_ERR_SUCCESS;
4140 }
4141
4142 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest2 *r)
4143 {
4144         uint32_t _ptr_naming_context;
4145         TALLOC_CTX *_mem_save_naming_context_0;
4146         uint32_t _ptr_source_dsa_dn;
4147         TALLOC_CTX *_mem_save_source_dsa_dn_0;
4148         uint32_t _ptr_transport_dn;
4149         TALLOC_CTX *_mem_save_transport_dn_0;
4150         uint32_t _ptr_source_dsa_address;
4151         TALLOC_CTX *_mem_save_source_dsa_address_0;
4152         if (ndr_flags & NDR_SCALARS) {
4153                 NDR_CHECK(ndr_pull_align(ndr, 5));
4154                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4155                 if (_ptr_naming_context) {
4156                         NDR_PULL_ALLOC(ndr, r->naming_context);
4157                 } else {
4158                         r->naming_context = NULL;
4159                 }
4160                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_dn));
4161                 if (_ptr_source_dsa_dn) {
4162                         NDR_PULL_ALLOC(ndr, r->source_dsa_dn);
4163                 } else {
4164                         r->source_dsa_dn = NULL;
4165                 }
4166                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_dn));
4167                 if (_ptr_transport_dn) {
4168                         NDR_PULL_ALLOC(ndr, r->transport_dn);
4169                 } else {
4170                         r->transport_dn = NULL;
4171                 }
4172                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4173                 if (_ptr_source_dsa_address) {
4174                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4175                 } else {
4176                         r->source_dsa_address = NULL;
4177                 }
4178                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4179                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options));
4180                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4181         }
4182         if (ndr_flags & NDR_BUFFERS) {
4183                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4184                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4185                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4186                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4187                 if (r->source_dsa_dn) {
4188                         _mem_save_source_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4189                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_dn, 0);
4190                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_dn_0, 0);
4192                 }
4193                 if (r->transport_dn) {
4194                         _mem_save_transport_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4195                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_dn, 0);
4196                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4197                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_dn_0, 0);
4198                 }
4199                 if (r->source_dsa_address) {
4200                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4201                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4202                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4203                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4204                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4205                                 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));
4206                         }
4207                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4208                         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));
4209                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4210                 }
4211         }
4212         return NDR_ERR_SUCCESS;
4213 }
4214
4215 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest2 *r)
4216 {
4217         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest2");
4218         ndr->depth++;
4219         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4220         ndr->depth++;
4221         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4222         ndr->depth--;
4223         ndr_print_ptr(ndr, "source_dsa_dn", r->source_dsa_dn);
4224         ndr->depth++;
4225         if (r->source_dsa_dn) {
4226                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "source_dsa_dn", r->source_dsa_dn);
4227         }
4228         ndr->depth--;
4229         ndr_print_ptr(ndr, "transport_dn", r->transport_dn);
4230         ndr->depth++;
4231         if (r->transport_dn) {
4232                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "transport_dn", r->transport_dn);
4233         }
4234         ndr->depth--;
4235         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4236         ndr->depth++;
4237         if (r->source_dsa_address) {
4238                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4239         }
4240         ndr->depth--;
4241         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4242         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "options", r->options);
4243         ndr->depth--;
4244 }
4245
4246 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaAddRequest *r)
4247 {
4248         if (ndr_flags & NDR_SCALARS) {
4249                 int level = ndr_push_get_switch_value(ndr, r);
4250                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4251                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4252                 switch (level) {
4253                         case 1: {
4254                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4255                         break; }
4256
4257                         case 2: {
4258                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4259                         break; }
4260
4261                         default:
4262                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4263                 }
4264         }
4265         if (ndr_flags & NDR_BUFFERS) {
4266                 int level = ndr_push_get_switch_value(ndr, r);
4267                 switch (level) {
4268                         case 1:
4269                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4270                         break;
4271
4272                         case 2:
4273                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4274                         break;
4275
4276                         default:
4277                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4278                 }
4279         }
4280         return NDR_ERR_SUCCESS;
4281 }
4282
4283 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaAddRequest *r)
4284 {
4285         int level;
4286         int32_t _level;
4287         level = ndr_pull_get_switch_value(ndr, r);
4288         if (ndr_flags & NDR_SCALARS) {
4289                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4290                 if (_level != level) {
4291                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4292                 }
4293                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4294                 switch (level) {
4295                         case 1: {
4296                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4297                         break; }
4298
4299                         case 2: {
4300                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4301                         break; }
4302
4303                         default:
4304                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4305                 }
4306         }
4307         if (ndr_flags & NDR_BUFFERS) {
4308                 switch (level) {
4309                         case 1:
4310                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4311                         break;
4312
4313                         case 2:
4314                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4315                         break;
4316
4317                         default:
4318                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4319                 }
4320         }
4321         return NDR_ERR_SUCCESS;
4322 }
4323
4324 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaAddRequest *r)
4325 {
4326         int level;
4327         level = ndr_print_get_switch_value(ndr, r);
4328         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaAddRequest");
4329         switch (level) {
4330                 case 1:
4331                         ndr_print_drsuapi_DsReplicaAddRequest1(ndr, "req1", &r->req1);
4332                 break;
4333
4334                 case 2:
4335                         ndr_print_drsuapi_DsReplicaAddRequest2(ndr, "req2", &r->req2);
4336                 break;
4337
4338                 default:
4339                         ndr_print_bad_level(ndr, name, level);
4340         }
4341 }
4342
4343 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDeleteOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4344 {
4345         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4346         return NDR_ERR_SUCCESS;
4347 }
4348
4349 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDeleteOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4350 {
4351         uint32_t v;
4352         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4353         *r = v;
4354         return NDR_ERR_SUCCESS;
4355 }
4356
4357 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDeleteOptions(struct ndr_print *ndr, const char *name, uint32_t r)
4358 {
4359         ndr_print_uint32(ndr, name, r);
4360         ndr->depth++;
4361         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
4362         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
4363         ndr->depth--;
4364 }
4365
4366 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaDelRequest1 *r)
4367 {
4368         if (ndr_flags & NDR_SCALARS) {
4369                 NDR_CHECK(ndr_push_align(ndr, 5));
4370                 if (r->naming_context == NULL) {
4371                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4372                 }
4373                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4374                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4375                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->options));
4376                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4377         }
4378         if (ndr_flags & NDR_BUFFERS) {
4379                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4380                 if (r->source_dsa_address) {
4381                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4382                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4383                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4384                         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));
4385                 }
4386         }
4387         return NDR_ERR_SUCCESS;
4388 }
4389
4390 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaDelRequest1 *r)
4391 {
4392         uint32_t _ptr_naming_context;
4393         TALLOC_CTX *_mem_save_naming_context_0;
4394         uint32_t _ptr_source_dsa_address;
4395         TALLOC_CTX *_mem_save_source_dsa_address_0;
4396         if (ndr_flags & NDR_SCALARS) {
4397                 NDR_CHECK(ndr_pull_align(ndr, 5));
4398                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4399                 if (_ptr_naming_context) {
4400                         NDR_PULL_ALLOC(ndr, r->naming_context);
4401                 } else {
4402                         r->naming_context = NULL;
4403                 }
4404                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4405                 if (_ptr_source_dsa_address) {
4406                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4407                 } else {
4408                         r->source_dsa_address = NULL;
4409                 }
4410                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->options));
4411                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4412         }
4413         if (ndr_flags & NDR_BUFFERS) {
4414                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4415                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4416                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4417                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4418                 if (r->source_dsa_address) {
4419                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4420                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4421                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4422                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4423                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4424                                 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));
4425                         }
4426                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4427                         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));
4428                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4429                 }
4430         }
4431         return NDR_ERR_SUCCESS;
4432 }
4433
4434 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaDelRequest1 *r)
4435 {
4436         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDelRequest1");
4437         ndr->depth++;
4438         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4439         ndr->depth++;
4440         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4441         ndr->depth--;
4442         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4443         ndr->depth++;
4444         if (r->source_dsa_address) {
4445                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4446         }
4447         ndr->depth--;
4448         ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "options", r->options);
4449         ndr->depth--;
4450 }
4451
4452 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaDelRequest *r)
4453 {
4454         if (ndr_flags & NDR_SCALARS) {
4455                 int level = ndr_push_get_switch_value(ndr, r);
4456                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4457                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4458                 switch (level) {
4459                         case 1: {
4460                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4461                         break; }
4462
4463                         default:
4464                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4465                 }
4466         }
4467         if (ndr_flags & NDR_BUFFERS) {
4468                 int level = ndr_push_get_switch_value(ndr, r);
4469                 switch (level) {
4470                         case 1:
4471                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4472                         break;
4473
4474                         default:
4475                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4476                 }
4477         }
4478         return NDR_ERR_SUCCESS;
4479 }
4480
4481 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaDelRequest *r)
4482 {
4483         int level;
4484         int32_t _level;
4485         level = ndr_pull_get_switch_value(ndr, r);
4486         if (ndr_flags & NDR_SCALARS) {
4487                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4488                 if (_level != level) {
4489                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4490                 }
4491                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4492                 switch (level) {
4493                         case 1: {
4494                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4495                         break; }
4496
4497                         default:
4498                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4499                 }
4500         }
4501         if (ndr_flags & NDR_BUFFERS) {
4502                 switch (level) {
4503                         case 1:
4504                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4505                         break;
4506
4507                         default:
4508                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4509                 }
4510         }
4511         return NDR_ERR_SUCCESS;
4512 }
4513
4514 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaDelRequest *r)
4515 {
4516         int level;
4517         level = ndr_print_get_switch_value(ndr, r);
4518         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaDelRequest");
4519         switch (level) {
4520                 case 1:
4521                         ndr_print_drsuapi_DsReplicaDelRequest1(ndr, "req1", &r->req1);
4522                 break;
4523
4524                 default:
4525                         ndr_print_bad_level(ndr, name, level);
4526         }
4527 }
4528
4529 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModifyOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4530 {
4531         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4532         return NDR_ERR_SUCCESS;
4533 }
4534
4535 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModifyOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4536 {
4537         uint32_t v;
4538         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4539         *r = v;
4540         return NDR_ERR_SUCCESS;
4541 }
4542
4543 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModifyOptions(struct ndr_print *ndr, const char *name, uint32_t r)
4544 {
4545         ndr_print_uint32(ndr, name, r);
4546         ndr->depth++;
4547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
4548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
4549         ndr->depth--;
4550 }
4551
4552 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaModRequest1 *r)
4553 {
4554         if (ndr_flags & NDR_SCALARS) {
4555                 NDR_CHECK(ndr_push_align(ndr, 5));
4556                 if (r->naming_context == NULL) {
4557                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4558                 }
4559                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4560                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dra));
4561                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dra_address));
4562                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->replica_flags));
4564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->modify_fields));
4565                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->options));
4566                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4567         }
4568         if (ndr_flags & NDR_BUFFERS) {
4569                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4570                 if (r->source_dra_address) {
4571                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4572                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4573                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4574                         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));
4575                 }
4576         }
4577         return NDR_ERR_SUCCESS;
4578 }
4579
4580 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaModRequest1 *r)
4581 {
4582         uint32_t _ptr_naming_context;
4583         TALLOC_CTX *_mem_save_naming_context_0;
4584         uint32_t _ptr_source_dra_address;
4585         TALLOC_CTX *_mem_save_source_dra_address_0;
4586         if (ndr_flags & NDR_SCALARS) {
4587                 NDR_CHECK(ndr_pull_align(ndr, 5));
4588                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4589                 if (_ptr_naming_context) {
4590                         NDR_PULL_ALLOC(ndr, r->naming_context);
4591                 } else {
4592                         r->naming_context = NULL;
4593                 }
4594                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dra));
4595                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dra_address));
4596                 if (_ptr_source_dra_address) {
4597                         NDR_PULL_ALLOC(ndr, r->source_dra_address);
4598                 } else {
4599                         r->source_dra_address = NULL;
4600                 }
4601                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4602                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->replica_flags));
4603                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->modify_fields));
4604                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->options));
4605                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4606         }
4607         if (ndr_flags & NDR_BUFFERS) {
4608                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4609                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4610                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4611                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4612                 if (r->source_dra_address) {
4613                         _mem_save_source_dra_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4614                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dra_address, 0);
4615                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dra_address));
4616                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dra_address));
4617                         if (ndr_get_array_length(ndr, &r->source_dra_address) > ndr_get_array_size(ndr, &r->source_dra_address)) {
4618                                 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));
4619                         }
4620                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t)));
4621                         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));
4622                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dra_address_0, 0);
4623                 }
4624         }
4625         return NDR_ERR_SUCCESS;
4626 }
4627
4628 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaModRequest1 *r)
4629 {
4630         ndr_print_struct(ndr, name, "drsuapi_DsReplicaModRequest1");
4631         ndr->depth++;
4632         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4633         ndr->depth++;
4634         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4635         ndr->depth--;
4636         ndr_print_GUID(ndr, "source_dra", &r->source_dra);
4637         ndr_print_ptr(ndr, "source_dra_address", r->source_dra_address);
4638         ndr->depth++;
4639         if (r->source_dra_address) {
4640                 ndr_print_string(ndr, "source_dra_address", r->source_dra_address);
4641         }
4642         ndr->depth--;
4643         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4644         ndr_print_uint32(ndr, "replica_flags", r->replica_flags);
4645         ndr_print_uint32(ndr, "modify_fields", r->modify_fields);
4646         ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "options", r->options);
4647         ndr->depth--;
4648 }
4649
4650 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaModRequest *r)
4651 {
4652         if (ndr_flags & NDR_SCALARS) {
4653                 int level = ndr_push_get_switch_value(ndr, r);
4654                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4655                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4656                 switch (level) {
4657                         case 1: {
4658                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4659                         break; }
4660
4661                         default:
4662                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4663                 }
4664         }
4665         if (ndr_flags & NDR_BUFFERS) {
4666                 int level = ndr_push_get_switch_value(ndr, r);
4667                 switch (level) {
4668                         case 1:
4669                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4670                         break;
4671
4672                         default:
4673                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4674                 }
4675         }
4676         return NDR_ERR_SUCCESS;
4677 }
4678
4679 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaModRequest *r)
4680 {
4681         int level;
4682         int32_t _level;
4683         level = ndr_pull_get_switch_value(ndr, r);
4684         if (ndr_flags & NDR_SCALARS) {
4685                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4686                 if (_level != level) {
4687                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4688                 }
4689                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4690                 switch (level) {
4691                         case 1: {
4692                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4693                         break; }
4694
4695                         default:
4696                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4697                 }
4698         }
4699         if (ndr_flags & NDR_BUFFERS) {
4700                 switch (level) {
4701                         case 1:
4702                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4703                         break;
4704
4705                         default:
4706                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4707                 }
4708         }
4709         return NDR_ERR_SUCCESS;
4710 }
4711
4712 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaModRequest *r)
4713 {
4714         int level;
4715         level = ndr_print_get_switch_value(ndr, r);
4716         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaModRequest");
4717         switch (level) {
4718                 case 1:
4719                         ndr_print_drsuapi_DsReplicaModRequest1(ndr, "req1", &r->req1);
4720                 break;
4721
4722                 default:
4723                         ndr_print_bad_level(ndr, name, level);
4724         }
4725 }
4726
4727 static enum ndr_err_code ndr_push_drsuapi_DsMembershipType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsMembershipType r)
4728 {
4729         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
4730         return NDR_ERR_SUCCESS;
4731 }
4732
4733 static enum ndr_err_code ndr_pull_drsuapi_DsMembershipType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsMembershipType *r)
4734 {
4735         uint32_t v;
4736         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
4737         *r = v;
4738         return NDR_ERR_SUCCESS;
4739 }
4740
4741 _PUBLIC_ void ndr_print_drsuapi_DsMembershipType(struct ndr_print *ndr, const char *name, enum drsuapi_DsMembershipType r)
4742 {
4743         const char *val = NULL;
4744
4745         switch (r) {
4746                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS"; break;
4747                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS"; break;
4748                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS"; break;
4749                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2"; break;
4750                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS"; break;
4751                 case DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS"; break;
4752                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2"; break;
4753         }
4754         ndr_print_enum(ndr, name, "ENUM", val, r);
4755 }
4756
4757 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsCtr1 *r)
4758 {
4759         uint32_t cntr_info_array_1;
4760         uint32_t cntr_group_attrs_1;
4761         uint32_t cntr_sids_1;
4762         if (ndr_flags & NDR_SCALARS) {
4763                 NDR_CHECK(ndr_push_align(ndr, 5));
4764                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
4765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
4766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
4767                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4768                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_attrs));
4769                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
4770                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4771         }
4772         if (ndr_flags & NDR_BUFFERS) {
4773                 if (r->info_array) {
4774                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4775                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4776                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4777                         }
4778                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4779                                 if (r->info_array[cntr_info_array_1]) {
4780                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4781                                 }
4782                         }
4783                 }
4784                 if (r->group_attrs) {
4785                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4786                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4787                                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->group_attrs[cntr_group_attrs_1]));
4788                         }
4789                 }
4790                 if (r->sids) {
4791                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_sids));
4792                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4793                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_1]));
4794                         }
4795                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4796                                 if (r->sids[cntr_sids_1]) {
4797                                         NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4798                                 }
4799                         }
4800                 }
4801         }
4802         return NDR_ERR_SUCCESS;
4803 }
4804
4805 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsCtr1 *r)
4806 {
4807         uint32_t _ptr_info_array;
4808         uint32_t cntr_info_array_1;
4809         TALLOC_CTX *_mem_save_info_array_0;
4810         TALLOC_CTX *_mem_save_info_array_1;
4811         TALLOC_CTX *_mem_save_info_array_2;
4812         uint32_t _ptr_group_attrs;
4813         uint32_t cntr_group_attrs_1;
4814         TALLOC_CTX *_mem_save_group_attrs_0;
4815         TALLOC_CTX *_mem_save_group_attrs_1;
4816         uint32_t _ptr_sids;
4817         uint32_t cntr_sids_1;
4818         TALLOC_CTX *_mem_save_sids_0;
4819         TALLOC_CTX *_mem_save_sids_1;
4820         TALLOC_CTX *_mem_save_sids_2;
4821         if (ndr_flags & NDR_SCALARS) {
4822                 NDR_CHECK(ndr_pull_align(ndr, 5));
4823                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
4824                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_memberships));
4825                 if (r->num_memberships > 10000) {
4826                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4827                 }
4828                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
4829                 if (r->num_sids > 10000) {
4830                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4831                 }
4832                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4833                 if (_ptr_info_array) {
4834                         NDR_PULL_ALLOC(ndr, r->info_array);
4835                 } else {
4836                         r->info_array = NULL;
4837                 }
4838                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_attrs));
4839                 if (_ptr_group_attrs) {
4840                         NDR_PULL_ALLOC(ndr, r->group_attrs);
4841                 } else {
4842                         r->group_attrs = NULL;
4843                 }
4844                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4845                 if (_ptr_sids) {
4846                         NDR_PULL_ALLOC(ndr, r->sids);
4847                 } else {
4848                         r->sids = NULL;
4849                 }
4850                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4851         }
4852         if (ndr_flags & NDR_BUFFERS) {
4853                 if (r->info_array) {
4854                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4855                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4856                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4857                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
4858                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4859                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4860                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4861                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4862                                 if (_ptr_info_array) {
4863                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4864                                 } else {
4865                                         r->info_array[cntr_info_array_1] = NULL;
4866                                 }
4867                         }
4868                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4869                                 if (r->info_array[cntr_info_array_1]) {
4870                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4871                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4872                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4873                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
4874                                 }
4875                         }
4876                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
4877                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
4878                 }
4879                 if (r->group_attrs) {
4880                         _mem_save_group_attrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
4881                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4882                         NDR_CHECK(ndr_pull_array_size(ndr, &r->group_attrs));
4883                         NDR_PULL_ALLOC_N(ndr, r->group_attrs, ndr_get_array_size(ndr, &r->group_attrs));
4884                         _mem_save_group_attrs_1 = NDR_PULL_GET_MEM_CTX(ndr);
4885                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4886                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4887                                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->group_attrs[cntr_group_attrs_1]));
4888                         }
4889                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_1, 0);
4890                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_0, 0);
4891                 }
4892                 if (r->sids) {
4893                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4894                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4895                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4896                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4897                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4898                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4899                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4900                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4901                                 if (_ptr_sids) {
4902                                         NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_1]);
4903                                 } else {
4904                                         r->sids[cntr_sids_1] = NULL;
4905                                 }
4906                         }
4907                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4908                                 if (r->sids[cntr_sids_1]) {
4909                                         _mem_save_sids_2 = NDR_PULL_GET_MEM_CTX(ndr);
4910                                         NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_1], 0);
4911                                         NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4912                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_2, 0);
4913                                 }
4914                         }
4915                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
4916                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
4917                 }
4918                 if (r->info_array) {
4919                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->num_memberships));
4920                 }
4921                 if (r->group_attrs) {
4922                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->group_attrs, r->num_memberships));
4923                 }
4924                 if (r->sids) {
4925                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
4926                 }
4927         }
4928         return NDR_ERR_SUCCESS;
4929 }
4930
4931 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsCtr1 *r)
4932 {
4933         uint32_t cntr_info_array_1;
4934         uint32_t cntr_group_attrs_1;
4935         uint32_t cntr_sids_1;
4936         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsCtr1");
4937         ndr->depth++;
4938         ndr_print_NTSTATUS(ndr, "status", r->status);
4939         ndr_print_uint32(ndr, "num_memberships", r->num_memberships);
4940         ndr_print_uint32(ndr, "num_sids", r->num_sids);
4941         ndr_print_ptr(ndr, "info_array", r->info_array);
4942         ndr->depth++;
4943         if (r->info_array) {
4944                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->num_memberships);
4945                 ndr->depth++;
4946                 for (cntr_info_array_1=0;cntr_info_array_1<r->num_memberships;cntr_info_array_1++) {
4947                         char *idx_1=NULL;
4948                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
4949                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
4950                                 ndr->depth++;
4951                                 if (r->info_array[cntr_info_array_1]) {
4952                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
4953                                 }
4954                                 ndr->depth--;
4955                                 free(idx_1);
4956                         }
4957                 }
4958                 ndr->depth--;
4959         }
4960         ndr->depth--;
4961         ndr_print_ptr(ndr, "group_attrs", r->group_attrs);
4962         ndr->depth++;
4963         if (r->group_attrs) {
4964                 ndr->print(ndr, "%s: ARRAY(%d)", "group_attrs", (int)r->num_memberships);
4965                 ndr->depth++;
4966                 for (cntr_group_attrs_1=0;cntr_group_attrs_1<r->num_memberships;cntr_group_attrs_1++) {
4967                         char *idx_1=NULL;
4968                         if (asprintf(&idx_1, "[%d]", cntr_group_attrs_1) != -1) {
4969                                 ndr_print_samr_GroupAttrs(ndr, "group_attrs", r->group_attrs[cntr_group_attrs_1]);
4970                                 free(idx_1);
4971                         }
4972                 }
4973                 ndr->depth--;
4974         }
4975         ndr->depth--;
4976         ndr_print_ptr(ndr, "sids", r->sids);
4977         ndr->depth++;
4978         if (r->sids) {
4979                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
4980                 ndr->depth++;
4981                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
4982                         char *idx_1=NULL;
4983                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4984                                 ndr_print_ptr(ndr, "sids", r->sids[cntr_sids_1]);
4985                                 ndr->depth++;
4986                                 if (r->sids[cntr_sids_1]) {
4987                                         ndr_print_dom_sid28(ndr, "sids", r->sids[cntr_sids_1]);
4988                                 }
4989                                 ndr->depth--;
4990                                 free(idx_1);
4991                         }
4992                 }
4993                 ndr->depth--;
4994         }
4995         ndr->depth--;
4996         ndr->depth--;
4997 }
4998
4999 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsCtr *r)
5000 {
5001         if (ndr_flags & NDR_SCALARS) {
5002                 int level = ndr_push_get_switch_value(ndr, r);
5003                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5004                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5005                 switch (level) {
5006                         case 1: {
5007                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
5008                         break; }
5009
5010                         default:
5011                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5012                 }
5013         }
5014         if (ndr_flags & NDR_BUFFERS) {
5015                 int level = ndr_push_get_switch_value(ndr, r);
5016                 switch (level) {
5017                         case 1:
5018                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
5019                         break;
5020
5021                         default:
5022                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5023                 }
5024         }
5025         return NDR_ERR_SUCCESS;
5026 }
5027
5028 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsCtr *r)
5029 {
5030         int level;
5031         int32_t _level;
5032         level = ndr_pull_get_switch_value(ndr, r);
5033         if (ndr_flags & NDR_SCALARS) {
5034                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5035                 if (_level != level) {
5036                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5037                 }
5038                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5039                 switch (level) {
5040                         case 1: {
5041                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
5042                         break; }
5043
5044                         default:
5045                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5046                 }
5047         }
5048         if (ndr_flags & NDR_BUFFERS) {
5049                 switch (level) {
5050                         case 1:
5051                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
5052                         break;
5053
5054                         default:
5055                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5056                 }
5057         }
5058         return NDR_ERR_SUCCESS;
5059 }
5060
5061 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsCtr *r)
5062 {
5063         int level;
5064         level = ndr_print_get_switch_value(ndr, r);
5065         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsCtr");
5066         switch (level) {
5067                 case 1:
5068                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
5069                 break;
5070
5071                 default:
5072                         ndr_print_bad_level(ndr, name, level);
5073         }
5074 }
5075
5076 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsRequest1 *r)
5077 {
5078         uint32_t cntr_info_array_1;
5079         if (ndr_flags & NDR_SCALARS) {
5080                 NDR_CHECK(ndr_push_align(ndr, 5));
5081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5082                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
5083                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
5084                 NDR_CHECK(ndr_push_drsuapi_DsMembershipType(ndr, NDR_SCALARS, r->type));
5085                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
5086                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5087         }
5088         if (ndr_flags & NDR_BUFFERS) {
5089                 if (r->info_array) {
5090                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5091                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5092                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
5093                         }
5094                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5095                                 if (r->info_array[cntr_info_array_1]) {
5096                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5097                                 }
5098                         }
5099                 }
5100                 if (r->domain) {
5101                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5102                 }
5103         }
5104         return NDR_ERR_SUCCESS;
5105 }
5106
5107 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsRequest1 *r)
5108 {
5109         uint32_t _ptr_info_array;
5110         uint32_t cntr_info_array_1;
5111         TALLOC_CTX *_mem_save_info_array_0;
5112         TALLOC_CTX *_mem_save_info_array_1;
5113         TALLOC_CTX *_mem_save_info_array_2;
5114         uint32_t _ptr_domain;
5115         TALLOC_CTX *_mem_save_domain_0;
5116         if (ndr_flags & NDR_SCALARS) {
5117                 NDR_CHECK(ndr_pull_align(ndr, 5));
5118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5119                 if (r->count < 1 || r->count > 10000) {
5120                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5121                 }
5122                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5123                 if (_ptr_info_array) {
5124                         NDR_PULL_ALLOC(ndr, r->info_array);
5125                 } else {
5126                         r->info_array = NULL;
5127                 }
5128                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
5129                 NDR_CHECK(ndr_pull_drsuapi_DsMembershipType(ndr, NDR_SCALARS, &r->type));
5130                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
5131                 if (_ptr_domain) {
5132                         NDR_PULL_ALLOC(ndr, r->domain);
5133                 } else {
5134                         r->domain = NULL;
5135                 }
5136                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5137         }
5138         if (ndr_flags & NDR_BUFFERS) {
5139                 if (r->info_array) {
5140                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5141                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5142                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
5143                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
5144                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5145                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5146                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5147                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5148                                 if (_ptr_info_array) {
5149                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
5150                                 } else {
5151                                         r->info_array[cntr_info_array_1] = NULL;
5152                                 }
5153                         }
5154                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5155                                 if (r->info_array[cntr_info_array_1]) {
5156                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
5157                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
5158                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5159                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
5160                                 }
5161                         }
5162                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
5163                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
5164                 }
5165                 if (r->domain) {
5166                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
5167                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
5168                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5169                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
5170                 }
5171                 if (r->info_array) {
5172                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->count));
5173                 }
5174         }
5175         return NDR_ERR_SUCCESS;
5176 }
5177
5178 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsRequest1 *r)
5179 {
5180         uint32_t cntr_info_array_1;
5181         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsRequest1");
5182         ndr->depth++;
5183         ndr_print_uint32(ndr, "count", r->count);
5184         ndr_print_ptr(ndr, "info_array", r->info_array);
5185         ndr->depth++;
5186         if (r->info_array) {
5187                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->count);
5188                 ndr->depth++;
5189                 for (cntr_info_array_1=0;cntr_info_array_1<r->count;cntr_info_array_1++) {
5190                         char *idx_1=NULL;
5191                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
5192                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
5193                                 ndr->depth++;
5194                                 if (r->info_array[cntr_info_array_1]) {
5195                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
5196                                 }
5197                                 ndr->depth--;
5198                                 free(idx_1);
5199                         }
5200                 }
5201                 ndr->depth--;
5202         }
5203         ndr->depth--;
5204         ndr_print_uint32(ndr, "flags", r->flags);
5205         ndr_print_drsuapi_DsMembershipType(ndr, "type", r->type);
5206         ndr_print_ptr(ndr, "domain", r->domain);
5207         ndr->depth++;
5208         if (r->domain) {
5209                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "domain", r->domain);
5210         }
5211         ndr->depth--;
5212         ndr->depth--;
5213 }
5214
5215 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsRequest *r)
5216 {
5217         if (ndr_flags & NDR_SCALARS) {
5218                 int level = ndr_push_get_switch_value(ndr, r);
5219                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5220                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5221                 switch (level) {
5222                         case 1: {
5223                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5224                         break; }
5225
5226                         default:
5227                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5228                 }
5229         }
5230         if (ndr_flags & NDR_BUFFERS) {
5231                 int level = ndr_push_get_switch_value(ndr, r);
5232                 switch (level) {
5233                         case 1:
5234                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5235                         break;
5236
5237                         default:
5238                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5239                 }
5240         }
5241         return NDR_ERR_SUCCESS;
5242 }
5243
5244 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsRequest *r)
5245 {
5246         int level;
5247         int32_t _level;
5248         level = ndr_pull_get_switch_value(ndr, r);
5249         if (ndr_flags & NDR_SCALARS) {
5250                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5251                 if (_level != level) {
5252                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5253                 }
5254                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5255                 switch (level) {
5256                         case 1: {
5257                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5258                         break; }
5259
5260                         default:
5261                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5262                 }
5263         }
5264         if (ndr_flags & NDR_BUFFERS) {
5265                 switch (level) {
5266                         case 1:
5267                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5268                         break;
5269
5270                         default:
5271                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5272                 }
5273         }
5274         return NDR_ERR_SUCCESS;
5275 }
5276
5277 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsRequest *r)
5278 {
5279         int level;
5280         level = ndr_print_get_switch_value(ndr, r);
5281         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsRequest");
5282         switch (level) {
5283                 case 1:
5284                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req1", &r->req1);
5285                 break;
5286
5287                 default:
5288                         ndr_print_bad_level(ndr, name, level);
5289         }
5290 }
5291
5292 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5293 {
5294         if (ndr_flags & NDR_SCALARS) {
5295                 NDR_CHECK(ndr_push_align(ndr, 5));
5296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
5297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
5298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
5299                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
5300                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5301         }
5302         if (ndr_flags & NDR_BUFFERS) {
5303                 if (r->data) {
5304                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
5305                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
5306                 }
5307         }
5308         return NDR_ERR_SUCCESS;
5309 }
5310
5311 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5312 {
5313         uint32_t _ptr_data;
5314         TALLOC_CTX *_mem_save_data_0;
5315         if (ndr_flags & NDR_SCALARS) {
5316                 NDR_CHECK(ndr_pull_align(ndr, 5));
5317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
5318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
5319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
5320                 if (r->length > 0x00A00000) {
5321                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5322                 }
5323                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
5324                 if (_ptr_data) {
5325                         NDR_PULL_ALLOC(ndr, r->data);
5326                 } else {
5327                         r->data = NULL;
5328                 }
5329                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5330         }
5331         if (ndr_flags & NDR_BUFFERS) {
5332                 if (r->data) {
5333                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5334                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
5335                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
5336                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
5337                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
5338                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
5339                 }
5340                 if (r->data) {
5341                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
5342                 }
5343         }
5344         return NDR_ERR_SUCCESS;
5345 }
5346
5347 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5348 {
5349         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogRequest1");
5350         ndr->depth++;
5351         ndr_print_uint32(ndr, "unknown1", r->unknown1);
5352         ndr_print_uint32(ndr, "unknown2", r->unknown2);
5353         ndr_print_uint32(ndr, "length", r->length);
5354         ndr_print_ptr(ndr, "data", r->data);
5355         ndr->depth++;
5356         if (r->data) {
5357                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
5358         }
5359         ndr->depth--;
5360         ndr->depth--;
5361 }
5362
5363 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5364 {
5365         if (ndr_flags & NDR_SCALARS) {
5366                 int level = ndr_push_get_switch_value(ndr, r);
5367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5368                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5369                 switch (level) {
5370                         case 1: {
5371                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5372                         break; }
5373
5374                         default:
5375                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5376                 }
5377         }
5378         if (ndr_flags & NDR_BUFFERS) {
5379                 int level = ndr_push_get_switch_value(ndr, r);
5380                 switch (level) {
5381                         case 1:
5382                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5383                         break;
5384
5385                         default:
5386                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5387                 }
5388         }
5389         return NDR_ERR_SUCCESS;
5390 }
5391
5392 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogRequest *r)
5393 {
5394         int level;
5395         uint32_t _level;
5396         level = ndr_pull_get_switch_value(ndr, r);
5397         if (ndr_flags & NDR_SCALARS) {
5398                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5399                 if (_level != level) {
5400                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5401                 }
5402                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5403                 switch (level) {
5404                         case 1: {
5405                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5406                         break; }
5407
5408                         default:
5409                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5410                 }
5411         }
5412         if (ndr_flags & NDR_BUFFERS) {
5413                 switch (level) {
5414                         case 1:
5415                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5416                         break;
5417
5418                         default:
5419                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5420                 }
5421         }
5422         return NDR_ERR_SUCCESS;
5423 }
5424
5425 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5426 {
5427         int level;
5428         level = ndr_print_get_switch_value(ndr, r);
5429         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogRequest");
5430         switch (level) {
5431                 case 1:
5432                         ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(ndr, "req1", &r->req1);
5433                 break;
5434
5435                 default:
5436                         ndr_print_bad_level(ndr, name, level);
5437         }
5438 }
5439
5440 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5441 {
5442         if (ndr_flags & NDR_SCALARS) {
5443                 NDR_CHECK(ndr_push_align(ndr, 8));
5444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
5445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
5446                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5447                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time2));
5448                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5449                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time4));
5450                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5451                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time6));
5452                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
5453                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data1));
5454                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data2));
5455                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5456         }
5457         if (ndr_flags & NDR_BUFFERS) {
5458                 if (r->data1) {
5459                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length1));
5460                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data1, r->length1));
5461                 }
5462                 if (r->data2) {
5463                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length2));
5464                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data2, r->length2));
5465                 }
5466         }
5467         return NDR_ERR_SUCCESS;
5468 }
5469
5470 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5471 {
5472         uint32_t _ptr_data1;
5473         TALLOC_CTX *_mem_save_data1_0;
5474         uint32_t _ptr_data2;
5475         TALLOC_CTX *_mem_save_data2_0;
5476         if (ndr_flags & NDR_SCALARS) {
5477                 NDR_CHECK(ndr_pull_align(ndr, 8));
5478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length1));
5479                 if (r->length1 > 0x00A00000) {
5480                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5481                 }
5482                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length2));
5483                 if (r->length2 > 0x00A00000) {
5484                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5485                 }
5486                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5487                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time2));
5488                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5489                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time4));
5490                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5491                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time6));
5492                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
5493                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data1));
5494                 if (_ptr_data1) {
5495                         NDR_PULL_ALLOC(ndr, r->data1);
5496                 } else {
5497                         r->data1 = NULL;
5498                 }
5499                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data2));
5500                 if (_ptr_data2) {
5501                         NDR_PULL_ALLOC(ndr, r->data2);
5502                 } else {
5503                         r->data2 = NULL;
5504                 }
5505                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5506         }
5507         if (ndr_flags & NDR_BUFFERS) {
5508                 if (r->data1) {
5509                         _mem_save_data1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5510                         NDR_PULL_SET_MEM_CTX(ndr, r->data1, 0);
5511                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data1));
5512                         NDR_PULL_ALLOC_N(ndr, r->data1, ndr_get_array_size(ndr, &r->data1));
5513                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data1, ndr_get_array_size(ndr, &r->data1)));
5514                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data1_0, 0);
5515                 }
5516                 if (r->data2) {
5517                         _mem_save_data2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5518                         NDR_PULL_SET_MEM_CTX(ndr, r->data2, 0);
5519                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data2));
5520                         NDR_PULL_ALLOC_N(ndr, r->data2, ndr_get_array_size(ndr, &r->data2));
5521                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data2, ndr_get_array_size(ndr, &r->data2)));
5522                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data2_0, 0);
5523                 }
5524                 if (r->data1) {
5525                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data1, r->length1));
5526                 }
5527                 if (r->data2) {
5528                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data2, r->length2));
5529                 }
5530         }
5531         return NDR_ERR_SUCCESS;
5532 }
5533
5534 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5535 {
5536         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogInfo1");
5537         ndr->depth++;
5538         ndr_print_uint32(ndr, "length1", r->length1);
5539         ndr_print_uint32(ndr, "length2", r->length2);
5540         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5541         ndr_print_NTTIME(ndr, "time2", r->time2);
5542         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5543         ndr_print_NTTIME(ndr, "time4", r->time4);
5544         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5545         ndr_print_NTTIME(ndr, "time6", r->time6);
5546         ndr_print_NTSTATUS(ndr, "status", r->status);
5547         ndr_print_ptr(ndr, "data1", r->data1);
5548         ndr->depth++;
5549         if (r->data1) {
5550                 ndr_print_array_uint8(ndr, "data1", r->data1, r->length1);
5551         }
5552         ndr->depth--;
5553         ndr_print_ptr(ndr, "data2", r->data2);
5554         ndr->depth++;
5555         if (r->data2) {
5556                 ndr_print_array_uint8(ndr, "data2", r->data2, r->length2);
5557         }
5558         ndr->depth--;
5559         ndr->depth--;
5560 }
5561
5562 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5563 {
5564         if (ndr_flags & NDR_SCALARS) {
5565                 int level = ndr_push_get_switch_value(ndr, r);
5566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5567                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5568                 switch (level) {
5569                         case 1: {
5570                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5571                         break; }
5572
5573                         default:
5574                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5575                 }
5576         }
5577         if (ndr_flags & NDR_BUFFERS) {
5578                 int level = ndr_push_get_switch_value(ndr, r);
5579                 switch (level) {
5580                         case 1:
5581                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5582                         break;
5583
5584                         default:
5585                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5586                 }
5587         }
5588         return NDR_ERR_SUCCESS;
5589 }
5590
5591 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogInfo *r)
5592 {
5593         int level;
5594         uint32_t _level;
5595         level = ndr_pull_get_switch_value(ndr, r);
5596         if (ndr_flags & NDR_SCALARS) {
5597                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5598                 if (_level != level) {
5599                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5600                 }
5601                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5602                 switch (level) {
5603                         case 1: {
5604                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5605                         break; }
5606
5607                         default:
5608                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5609                 }
5610         }
5611         if (ndr_flags & NDR_BUFFERS) {
5612                 switch (level) {
5613                         case 1:
5614                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5615                         break;
5616
5617                         default:
5618                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5619                 }
5620         }
5621         return NDR_ERR_SUCCESS;
5622 }
5623
5624 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5625 {
5626         int level;
5627         level = ndr_print_get_switch_value(ndr, r);
5628         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogInfo");
5629         switch (level) {
5630                 case 1:
5631                         ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(ndr, "info1", &r->info1);
5632                 break;
5633
5634                 default:
5635                         ndr_print_bad_level(ndr, name, level);
5636         }
5637 }
5638
5639 static enum ndr_err_code ndr_push_drsuapi_DsNameStatus(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameStatus r)
5640 {
5641         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5642         return NDR_ERR_SUCCESS;
5643 }
5644
5645 static enum ndr_err_code ndr_pull_drsuapi_DsNameStatus(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameStatus *r)
5646 {
5647         uint32_t v;
5648         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5649         *r = v;
5650         return NDR_ERR_SUCCESS;
5651 }
5652
5653 _PUBLIC_ void ndr_print_drsuapi_DsNameStatus(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameStatus r)
5654 {
5655         const char *val = NULL;
5656
5657         switch (r) {
5658                 case DRSUAPI_DS_NAME_STATUS_OK: val = "DRSUAPI_DS_NAME_STATUS_OK"; break;
5659                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR: val = "DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR"; break;
5660                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND: val = "DRSUAPI_DS_NAME_STATUS_NOT_FOUND"; break;
5661                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE: val = "DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE"; break;
5662                 case DRSUAPI_DS_NAME_STATUS_NO_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_MAPPING"; break;
5663                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY: val = "DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY"; break;
5664                 case DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING"; break;
5665                 case DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL"; break;
5666         }
5667         ndr_print_enum(ndr, name, "ENUM", val, r);
5668 }
5669
5670 static enum ndr_err_code ndr_push_drsuapi_DsNameFlags(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFlags r)
5671 {
5672         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5673         return NDR_ERR_SUCCESS;
5674 }
5675
5676 static enum ndr_err_code ndr_pull_drsuapi_DsNameFlags(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFlags *r)
5677 {
5678         uint32_t v;
5679         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5680         *r = v;
5681         return NDR_ERR_SUCCESS;
5682 }
5683
5684 _PUBLIC_ void ndr_print_drsuapi_DsNameFlags(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFlags r)
5685 {
5686         const char *val = NULL;
5687
5688         switch (r) {
5689                 case DRSUAPI_DS_NAME_FLAG_NO_FLAGS: val = "DRSUAPI_DS_NAME_FLAG_NO_FLAGS"; break;
5690                 case DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY: val = "DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY"; break;
5691                 case DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC: val = "DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC"; break;
5692                 case DRSUAPI_DS_NAME_FLAG_GCVERIFY: val = "DRSUAPI_DS_NAME_FLAG_GCVERIFY"; break;
5693                 case DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL"; break;
5694         }
5695         ndr_print_enum(ndr, name, "ENUM", val, r);
5696 }
5697
5698 static enum ndr_err_code ndr_push_drsuapi_DsNameFormat(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFormat r)
5699 {
5700         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5701         return NDR_ERR_SUCCESS;
5702 }
5703
5704 static enum ndr_err_code ndr_pull_drsuapi_DsNameFormat(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFormat *r)
5705 {
5706         uint32_t v;
5707         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5708         *r = v;
5709         return NDR_ERR_SUCCESS;
5710 }
5711
5712 _PUBLIC_ void ndr_print_drsuapi_DsNameFormat(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFormat r)
5713 {
5714         const char *val = NULL;
5715
5716         switch (r) {
5717                 case DRSUAPI_DS_NAME_FORMAT_UNKNOWN: val = "DRSUAPI_DS_NAME_FORMAT_UNKNOWN"; break;
5718                 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: val = "DRSUAPI_DS_NAME_FORMAT_FQDN_1779"; break;
5719                 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: val = "DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT"; break;
5720                 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: val = "DRSUAPI_DS_NAME_FORMAT_DISPLAY"; break;
5721                 case DRSUAPI_DS_NAME_FORMAT_GUID: val = "DRSUAPI_DS_NAME_FORMAT_GUID"; break;
5722                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL"; break;
5723                 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL"; break;
5724                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX"; break;
5725                 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL"; break;
5726                 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: val = "DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY"; break;
5727                 case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: val = "DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN"; break;
5728         }
5729         ndr_print_enum(ndr, name, "ENUM", val, r);
5730 }
5731
5732 static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameString *r)
5733 {
5734         if (ndr_flags & NDR_SCALARS) {
5735                 NDR_CHECK(ndr_push_align(ndr, 5));
5736                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
5737                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5738         }
5739         if (ndr_flags & NDR_BUFFERS) {
5740                 if (r->str) {
5741                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5742                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5743                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5744                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str, ndr_charset_length(r->str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5745                 }
5746         }
5747         return NDR_ERR_SUCCESS;
5748 }
5749
5750 static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameString *r)
5751 {
5752         uint32_t _ptr_str;
5753         TALLOC_CTX *_mem_save_str_0;
5754         if (ndr_flags & NDR_SCALARS) {
5755                 NDR_CHECK(ndr_pull_align(ndr, 5));
5756                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
5757                 if (_ptr_str) {
5758                         NDR_PULL_ALLOC(ndr, r->str);
5759                 } else {
5760                         r->str = NULL;
5761                 }
5762                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5763         }
5764         if (ndr_flags & NDR_BUFFERS) {
5765                 if (r->str) {
5766                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
5767                         NDR_PULL_SET_MEM_CTX(ndr, r->str, 0);
5768                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str));
5769                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str));
5770                         if (ndr_get_array_length(ndr, &r->str) > ndr_get_array_size(ndr, &r->str)) {
5771                                 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));
5772                         }
5773                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t)));
5774                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t), CH_UTF16));
5775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
5776                 }
5777         }
5778         return NDR_ERR_SUCCESS;
5779 }
5780
5781 _PUBLIC_ void ndr_print_drsuapi_DsNameString(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameString *r)
5782 {
5783         ndr_print_struct(ndr, name, "drsuapi_DsNameString");
5784         ndr->depth++;
5785         ndr_print_ptr(ndr, "str", r->str);
5786         ndr->depth++;
5787         if (r->str) {
5788                 ndr_print_string(ndr, "str", r->str);
5789         }
5790         ndr->depth--;
5791         ndr->depth--;
5792 }
5793
5794 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameRequest1 *r)
5795 {
5796         uint32_t cntr_names_1;
5797         if (ndr_flags & NDR_SCALARS) {
5798                 NDR_CHECK(ndr_push_align(ndr, 5));
5799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->codepage));
5800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->language));
5801                 NDR_CHECK(ndr_push_drsuapi_DsNameFlags(ndr, NDR_SCALARS, r->format_flags));
5802                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_offered));
5803                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
5804                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5805                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
5806                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5807         }
5808         if (ndr_flags & NDR_BUFFERS) {
5809                 if (r->names) {
5810                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5811                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5812                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5813                         }
5814                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5815                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5816                         }
5817                 }
5818         }
5819         return NDR_ERR_SUCCESS;
5820 }
5821
5822 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameRequest1 *r)
5823 {
5824         uint32_t _ptr_names;
5825         uint32_t cntr_names_1;
5826         TALLOC_CTX *_mem_save_names_0;
5827         TALLOC_CTX *_mem_save_names_1;
5828         if (ndr_flags & NDR_SCALARS) {
5829                 NDR_CHECK(ndr_pull_align(ndr, 5));
5830                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->codepage));
5831                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->language));
5832                 NDR_CHECK(ndr_pull_drsuapi_DsNameFlags(ndr, NDR_SCALARS, &r->format_flags));
5833                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_offered));
5834                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_desired));
5835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5836                 if (r->count < 1 || r->count > 10000) {
5837                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5838                 }
5839                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
5840                 if (_ptr_names) {
5841                         NDR_PULL_ALLOC(ndr, r->names);
5842                 } else {
5843                         r->names = NULL;
5844                 }
5845                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5846         }
5847         if (ndr_flags & NDR_BUFFERS) {
5848                 if (r->names) {
5849                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5850                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5851                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
5852                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
5853                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
5854                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5855                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5856                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5857                         }
5858                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5859                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5860                         }
5861                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
5862                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
5863                 }
5864                 if (r->names) {
5865                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
5866                 }
5867         }
5868         return NDR_ERR_SUCCESS;
5869 }
5870
5871 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameRequest1 *r)
5872 {
5873         uint32_t cntr_names_1;
5874         ndr_print_struct(ndr, name, "drsuapi_DsNameRequest1");
5875         ndr->depth++;
5876         ndr_print_uint32(ndr, "codepage", r->codepage);
5877         ndr_print_uint32(ndr, "language", r->language);
5878         ndr_print_drsuapi_DsNameFlags(ndr, "format_flags", r->format_flags);
5879         ndr_print_drsuapi_DsNameFormat(ndr, "format_offered", r->format_offered);
5880         ndr_print_drsuapi_DsNameFormat(ndr, "format_desired", r->format_desired);
5881         ndr_print_uint32(ndr, "count", r->count);
5882         ndr_print_ptr(ndr, "names", r->names);
5883         ndr->depth++;
5884         if (r->names) {
5885                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
5886                 ndr->depth++;
5887                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
5888                         char *idx_1=NULL;
5889                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
5890                                 ndr_print_drsuapi_DsNameString(ndr, "names", &r->names[cntr_names_1]);
5891                                 free(idx_1);
5892                         }
5893                 }
5894                 ndr->depth--;
5895         }
5896         ndr->depth--;
5897         ndr->depth--;
5898 }
5899
5900 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameRequest *r)
5901 {
5902         if (ndr_flags & NDR_SCALARS) {
5903                 int level = ndr_push_get_switch_value(ndr, r);
5904                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5905                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5906                 switch (level) {
5907                         case 1: {
5908                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5909                         break; }
5910
5911                         default:
5912                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5913                 }
5914         }
5915         if (ndr_flags & NDR_BUFFERS) {
5916                 int level = ndr_push_get_switch_value(ndr, r);
5917                 switch (level) {
5918                         case 1:
5919                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5920                         break;
5921
5922                         default:
5923                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5924                 }
5925         }
5926         return NDR_ERR_SUCCESS;
5927 }
5928
5929 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameRequest *r)
5930 {
5931         int level;
5932         int32_t _level;
5933         level = ndr_pull_get_switch_value(ndr, r);
5934         if (ndr_flags & NDR_SCALARS) {
5935                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5936                 if (_level != level) {
5937                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5938                 }
5939                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5940                 switch (level) {
5941                         case 1: {
5942                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5943                         break; }
5944
5945                         default:
5946                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5947                 }
5948         }
5949         if (ndr_flags & NDR_BUFFERS) {
5950                 switch (level) {
5951                         case 1:
5952                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5953                         break;
5954
5955                         default:
5956                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5957                 }
5958         }
5959         return NDR_ERR_SUCCESS;
5960 }
5961
5962 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameRequest *r)
5963 {
5964         int level;
5965         level = ndr_print_get_switch_value(ndr, r);
5966         ndr_print_union(ndr, name, level, "drsuapi_DsNameRequest");
5967         switch (level) {
5968                 case 1:
5969                         ndr_print_drsuapi_DsNameRequest1(ndr, "req1", &r->req1);
5970                 break;
5971
5972                 default:
5973                         ndr_print_bad_level(ndr, name, level);
5974         }
5975 }
5976
5977 static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameInfo1 *r)
5978 {
5979         if (ndr_flags & NDR_SCALARS) {
5980                 NDR_CHECK(ndr_push_align(ndr, 5));
5981                 NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
5982                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
5983                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
5984                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5985         }
5986         if (ndr_flags & NDR_BUFFERS) {
5987                 if (r->dns_domain_name) {
5988                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5989                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5990                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5991                         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));
5992                 }
5993                 if (r->result_name) {
5994                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5995                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5996                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5997                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->result_name, ndr_charset_length(r->result_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5998                 }
5999         }
6000         return NDR_ERR_SUCCESS;
6001 }
6002
6003 static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameInfo1 *r)
6004 {
6005         uint32_t _ptr_dns_domain_name;
6006         TALLOC_CTX *_mem_save_dns_domain_name_0;
6007         uint32_t _ptr_result_name;
6008         TALLOC_CTX *_mem_save_result_name_0;
6009         if (ndr_flags & NDR_SCALARS) {
6010                 NDR_CHECK(ndr_pull_align(ndr, 5));
6011                 NDR_CHECK(ndr_pull_drsuapi_DsNameStatus(ndr, NDR_SCALARS, &r->status));
6012                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain_name));
6013                 if (_ptr_dns_domain_name) {
6014                         NDR_PULL_ALLOC(ndr, r->dns_domain_name);
6015                 } else {
6016                         r->dns_domain_name = NULL;
6017                 }
6018                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_result_name));
6019                 if (_ptr_result_name) {
6020                         NDR_PULL_ALLOC(ndr, r->result_name);
6021                 } else {
6022                         r->result_name = NULL;
6023                 }
6024                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6025         }
6026         if (ndr_flags & NDR_BUFFERS) {
6027                 if (r->dns_domain_name) {
6028                         _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6029                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
6030                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain_name));
6031                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain_name));
6032                         if (ndr_get_array_length(ndr, &r->dns_domain_name) > ndr_get_array_size(ndr, &r->dns_domain_name)) {
6033                                 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));
6034                         }
6035                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t)));
6036                         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));
6037                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
6038                 }
6039                 if (r->result_name) {
6040                         _mem_save_result_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6041                         NDR_PULL_SET_MEM_CTX(ndr, r->result_name, 0);
6042                         NDR_CHECK(ndr_pull_array_size(ndr, &r->result_name));
6043                         NDR_CHECK(ndr_pull_array_length(ndr, &r->result_name));
6044                         if (ndr_get_array_length(ndr, &r->result_name) > ndr_get_array_size(ndr, &r->result_name)) {
6045                                 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));
6046                         }
6047                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t)));
6048                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t), CH_UTF16));
6049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_result_name_0, 0);
6050                 }
6051         }
6052         return NDR_ERR_SUCCESS;
6053 }
6054
6055 _PUBLIC_ void ndr_print_drsuapi_DsNameInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameInfo1 *r)
6056 {
6057         ndr_print_struct(ndr, name, "drsuapi_DsNameInfo1");
6058         ndr->depth++;
6059         ndr_print_drsuapi_DsNameStatus(ndr, "status", r->status);
6060         ndr_print_ptr(ndr, "dns_domain_name", r->dns_domain_name);
6061         ndr->depth++;
6062         if (r->dns_domain_name) {
6063                 ndr_print_string(ndr, "dns_domain_name", r->dns_domain_name);
6064         }
6065         ndr->depth--;
6066         ndr_print_ptr(ndr, "result_name", r->result_name);
6067         ndr->depth++;
6068         if (r->result_name) {
6069                 ndr_print_string(ndr, "result_name", r->result_name);
6070         }
6071         ndr->depth--;
6072         ndr->depth--;
6073 }
6074
6075 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameCtr1 *r)
6076 {
6077         uint32_t cntr_array_1;
6078         if (ndr_flags & NDR_SCALARS) {
6079                 NDR_CHECK(ndr_push_align(ndr, 5));
6080                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6081                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
6082                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6083         }
6084         if (ndr_flags & NDR_BUFFERS) {
6085                 if (r->array) {
6086                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6087                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6088                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6089                         }
6090                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6091                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6092                         }
6093                 }
6094         }
6095         return NDR_ERR_SUCCESS;
6096 }
6097
6098 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameCtr1 *r)
6099 {
6100         uint32_t _ptr_array;
6101         uint32_t cntr_array_1;
6102         TALLOC_CTX *_mem_save_array_0;
6103         TALLOC_CTX *_mem_save_array_1;
6104         if (ndr_flags & NDR_SCALARS) {
6105                 NDR_CHECK(ndr_pull_align(ndr, 5));
6106                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
6108                 if (_ptr_array) {
6109                         NDR_PULL_ALLOC(ndr, r->array);
6110                 } else {
6111                         r->array = NULL;
6112                 }
6113                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6114         }
6115         if (ndr_flags & NDR_BUFFERS) {
6116                 if (r->array) {
6117                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6118                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6119                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
6120                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
6121                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
6122                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6123                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6124                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6125                         }
6126                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6127                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6128                         }
6129                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
6130                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
6131                 }
6132                 if (r->array) {
6133                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
6134                 }
6135         }
6136         return NDR_ERR_SUCCESS;
6137 }
6138
6139 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameCtr1 *r)
6140 {
6141         uint32_t cntr_array_1;
6142         ndr_print_struct(ndr, name, "drsuapi_DsNameCtr1");
6143         ndr->depth++;
6144         ndr_print_uint32(ndr, "count", r->count);
6145         ndr_print_ptr(ndr, "array", r->array);
6146         ndr->depth++;
6147         if (r->array) {
6148                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
6149                 ndr->depth++;
6150                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
6151                         char *idx_1=NULL;
6152                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
6153                                 ndr_print_drsuapi_DsNameInfo1(ndr, "array", &r->array[cntr_array_1]);
6154                                 free(idx_1);
6155                         }
6156                 }
6157                 ndr->depth--;
6158         }
6159         ndr->depth--;
6160         ndr->depth--;
6161 }
6162
6163 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameCtr *r)
6164 {
6165         if (ndr_flags & NDR_SCALARS) {
6166                 int level = ndr_push_get_switch_value(ndr, r);
6167                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6168                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6169                 switch (level) {
6170                         case 1: {
6171                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
6172                         break; }
6173
6174                         default:
6175                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6176                 }
6177         }
6178         if (ndr_flags & NDR_BUFFERS) {
6179                 int level = ndr_push_get_switch_value(ndr, r);
6180                 switch (level) {
6181                         case 1:
6182                                 if (r->ctr1) {
6183                                         NDR_CHECK(ndr_push_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6184                                 }
6185                         break;
6186
6187                         default:
6188                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6189                 }
6190         }
6191         return NDR_ERR_SUCCESS;
6192 }
6193
6194 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameCtr *r)
6195 {
6196         int level;
6197         int32_t _level;
6198         TALLOC_CTX *_mem_save_ctr1_0;
6199         level = ndr_pull_get_switch_value(ndr, r);
6200         if (ndr_flags & NDR_SCALARS) {
6201                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6202                 if (_level != level) {
6203                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6204                 }
6205                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6206                 switch (level) {
6207                         case 1: {
6208                                 uint32_t _ptr_ctr1;
6209                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
6210                                 if (_ptr_ctr1) {
6211                                         NDR_PULL_ALLOC(ndr, r->ctr1);
6212                                 } else {
6213                                         r->ctr1 = NULL;
6214                                 }
6215                         break; }
6216
6217                         default:
6218                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6219                 }
6220         }
6221         if (ndr_flags & NDR_BUFFERS) {
6222                 switch (level) {
6223                         case 1:
6224                                 if (r->ctr1) {
6225                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6226                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
6227                                         NDR_CHECK(ndr_pull_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6228                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
6229                                 }
6230                         break;
6231
6232                         default:
6233                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6234                 }
6235         }
6236         return NDR_ERR_SUCCESS;
6237 }
6238
6239 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameCtr *r)
6240 {
6241         int level;
6242         level = ndr_print_get_switch_value(ndr, r);
6243         ndr_print_union(ndr, name, level, "drsuapi_DsNameCtr");
6244         switch (level) {
6245                 case 1:
6246                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
6247                         ndr->depth++;
6248                         if (r->ctr1) {
6249                                 ndr_print_drsuapi_DsNameCtr1(ndr, "ctr1", r->ctr1);
6250                         }
6251                         ndr->depth--;
6252                 break;
6253
6254                 default:
6255                         ndr_print_bad_level(ndr, name, level);
6256         }
6257 }
6258
6259 static enum ndr_err_code ndr_push_drsuapi_DsSpnOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsSpnOperation r)
6260 {
6261         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6262         return NDR_ERR_SUCCESS;
6263 }
6264
6265 static enum ndr_err_code ndr_pull_drsuapi_DsSpnOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsSpnOperation *r)
6266 {
6267         uint32_t v;
6268         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6269         *r = v;
6270         return NDR_ERR_SUCCESS;
6271 }
6272
6273 _PUBLIC_ void ndr_print_drsuapi_DsSpnOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsSpnOperation r)
6274 {
6275         const char *val = NULL;
6276
6277         switch (r) {
6278                 case DRSUAPI_DS_SPN_OPERATION_ADD: val = "DRSUAPI_DS_SPN_OPERATION_ADD"; break;
6279                 case DRSUAPI_DS_SPN_OPERATION_REPLACE: val = "DRSUAPI_DS_SPN_OPERATION_REPLACE"; break;
6280                 case DRSUAPI_DS_SPN_OPERATION_DELETE: val = "DRSUAPI_DS_SPN_OPERATION_DELETE"; break;
6281         }
6282         ndr_print_enum(ndr, name, "ENUM", val, r);
6283 }
6284
6285 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6286 {
6287         uint32_t cntr_spn_names_1;
6288         if (ndr_flags & NDR_SCALARS) {
6289                 NDR_CHECK(ndr_push_align(ndr, 5));
6290                 NDR_CHECK(ndr_push_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, r->operation));
6291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
6292                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
6293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6294                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
6295                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6296         }
6297         if (ndr_flags & NDR_BUFFERS) {
6298                 if (r->object_dn) {
6299                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6300                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6301                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6302                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6303                 }
6304                 if (r->spn_names) {
6305                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6306                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6307                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6308                         }
6309                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6310                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6311                         }
6312                 }
6313         }
6314         return NDR_ERR_SUCCESS;
6315 }
6316
6317 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnRequest1 *r)
6318 {
6319         uint32_t _ptr_object_dn;
6320         TALLOC_CTX *_mem_save_object_dn_0;
6321         uint32_t _ptr_spn_names;
6322         uint32_t cntr_spn_names_1;
6323         TALLOC_CTX *_mem_save_spn_names_0;
6324         TALLOC_CTX *_mem_save_spn_names_1;
6325         if (ndr_flags & NDR_SCALARS) {
6326                 NDR_CHECK(ndr_pull_align(ndr, 5));
6327                 NDR_CHECK(ndr_pull_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, &r->operation));
6328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
6329                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
6330                 if (_ptr_object_dn) {
6331                         NDR_PULL_ALLOC(ndr, r->object_dn);
6332                 } else {
6333                         r->object_dn = NULL;
6334                 }
6335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6336                 if (r->count > 10000) {
6337                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6338                 }
6339                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_spn_names));
6340                 if (_ptr_spn_names) {
6341                         NDR_PULL_ALLOC(ndr, r->spn_names);
6342                 } else {
6343                         r->spn_names = NULL;
6344                 }
6345                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6346         }
6347         if (ndr_flags & NDR_BUFFERS) {
6348                 if (r->object_dn) {
6349                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6350                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
6351                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
6352                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
6353                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
6354                                 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));
6355                         }
6356                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
6357                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
6358                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
6359                 }
6360                 if (r->spn_names) {
6361                         _mem_save_spn_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6362                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6363                         NDR_CHECK(ndr_pull_array_size(ndr, &r->spn_names));
6364                         NDR_PULL_ALLOC_N(ndr, r->spn_names, ndr_get_array_size(ndr, &r->spn_names));
6365                         _mem_save_spn_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
6366                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6367                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6368                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6369                         }
6370                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6371                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6372                         }
6373                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_1, 0);
6374                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_0, 0);
6375                 }
6376                 if (r->spn_names) {
6377                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->spn_names, r->count));
6378                 }
6379         }
6380         return NDR_ERR_SUCCESS;
6381 }
6382
6383 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6384 {
6385         uint32_t cntr_spn_names_1;
6386         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnRequest1");
6387         ndr->depth++;
6388         ndr_print_drsuapi_DsSpnOperation(ndr, "operation", r->operation);
6389         ndr_print_uint32(ndr, "unknown1", r->unknown1);
6390         ndr_print_ptr(ndr, "object_dn", r->object_dn);
6391         ndr->depth++;
6392         if (r->object_dn) {
6393                 ndr_print_string(ndr, "object_dn", r->object_dn);
6394         }
6395         ndr->depth--;
6396         ndr_print_uint32(ndr, "count", r->count);
6397         ndr_print_ptr(ndr, "spn_names", r->spn_names);
6398         ndr->depth++;
6399         if (r->spn_names) {
6400                 ndr->print(ndr, "%s: ARRAY(%d)", "spn_names", (int)r->count);
6401                 ndr->depth++;
6402                 for (cntr_spn_names_1=0;cntr_spn_names_1<r->count;cntr_spn_names_1++) {
6403                         char *idx_1=NULL;
6404                         if (asprintf(&idx_1, "[%d]", cntr_spn_names_1) != -1) {
6405                                 ndr_print_drsuapi_DsNameString(ndr, "spn_names", &r->spn_names[cntr_spn_names_1]);
6406                                 free(idx_1);
6407                         }
6408                 }
6409                 ndr->depth--;
6410         }
6411         ndr->depth--;
6412         ndr->depth--;
6413 }
6414
6415 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnRequest *r)
6416 {
6417         if (ndr_flags & NDR_SCALARS) {
6418                 int level = ndr_push_get_switch_value(ndr, r);
6419                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6420                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6421                 switch (level) {
6422                         case 1: {
6423                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6424                         break; }
6425
6426                         default:
6427                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6428                 }
6429         }
6430         if (ndr_flags & NDR_BUFFERS) {
6431                 int level = ndr_push_get_switch_value(ndr, r);
6432                 switch (level) {
6433                         case 1:
6434                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6435                         break;
6436
6437                         default:
6438                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6439                 }
6440         }
6441         return NDR_ERR_SUCCESS;
6442 }
6443
6444 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnRequest *r)
6445 {
6446         int level;
6447         int32_t _level;
6448         level = ndr_pull_get_switch_value(ndr, r);
6449         if (ndr_flags & NDR_SCALARS) {
6450                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6451                 if (_level != level) {
6452                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6453                 }
6454                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6455                 switch (level) {
6456                         case 1: {
6457                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6458                         break; }
6459
6460                         default:
6461                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6462                 }
6463         }
6464         if (ndr_flags & NDR_BUFFERS) {
6465                 switch (level) {
6466                         case 1:
6467                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6468                         break;
6469
6470                         default:
6471                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6472                 }
6473         }
6474         return NDR_ERR_SUCCESS;
6475 }
6476
6477 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnRequest *r)
6478 {
6479         int level;
6480         level = ndr_print_get_switch_value(ndr, r);
6481         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnRequest");
6482         switch (level) {
6483                 case 1:
6484                         ndr_print_drsuapi_DsWriteAccountSpnRequest1(ndr, "req1", &r->req1);
6485                 break;
6486
6487                 default:
6488                         ndr_print_bad_level(ndr, name, level);
6489         }
6490 }
6491
6492 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6493 {
6494         if (ndr_flags & NDR_SCALARS) {
6495                 NDR_CHECK(ndr_push_align(ndr, 4));
6496                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
6497                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6498         }
6499         if (ndr_flags & NDR_BUFFERS) {
6500         }
6501         return NDR_ERR_SUCCESS;
6502 }
6503
6504 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnResult1 *r)
6505 {
6506         if (ndr_flags & NDR_SCALARS) {
6507                 NDR_CHECK(ndr_pull_align(ndr, 4));
6508                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
6509                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6510         }
6511         if (ndr_flags & NDR_BUFFERS) {
6512         }
6513         return NDR_ERR_SUCCESS;
6514 }
6515
6516 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6517 {
6518         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnResult1");
6519         ndr->depth++;
6520         ndr_print_WERROR(ndr, "status", r->status);
6521         ndr->depth--;
6522 }
6523
6524 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnResult *r)
6525 {
6526         if (ndr_flags & NDR_SCALARS) {
6527                 int level = ndr_push_get_switch_value(ndr, r);
6528                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6529                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6530                 switch (level) {
6531                         case 1: {
6532                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6533                         break; }
6534
6535                         default:
6536                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6537                 }
6538         }
6539         if (ndr_flags & NDR_BUFFERS) {
6540                 int level = ndr_push_get_switch_value(ndr, r);
6541                 switch (level) {
6542                         case 1:
6543                         break;
6544
6545                         default:
6546                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6547                 }
6548         }
6549         return NDR_ERR_SUCCESS;
6550 }
6551
6552 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnResult *r)
6553 {
6554         int level;
6555         int32_t _level;
6556         level = ndr_pull_get_switch_value(ndr, r);
6557         if (ndr_flags & NDR_SCALARS) {
6558                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6559                 if (_level != level) {
6560                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6561                 }
6562                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6563                 switch (level) {
6564                         case 1: {
6565                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6566                         break; }
6567
6568                         default:
6569                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6570                 }
6571         }
6572         if (ndr_flags & NDR_BUFFERS) {
6573                 switch (level) {
6574                         case 1:
6575                         break;
6576
6577                         default:
6578                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6579                 }
6580         }
6581         return NDR_ERR_SUCCESS;
6582 }
6583
6584 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnResult *r)
6585 {
6586         int level;
6587         level = ndr_print_get_switch_value(ndr, r);
6588         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnResult");
6589         switch (level) {
6590                 case 1:
6591                         ndr_print_drsuapi_DsWriteAccountSpnResult1(ndr, "res1", &r->res1);
6592                 break;
6593
6594                 default:
6595                         ndr_print_bad_level(ndr, name, level);
6596         }
6597 }
6598
6599 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6600 {
6601         if (ndr_flags & NDR_SCALARS) {
6602                 NDR_CHECK(ndr_push_align(ndr, 5));
6603                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
6605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->commit));
6606                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6607         }
6608         if (ndr_flags & NDR_BUFFERS) {
6609                 if (r->server_dn) {
6610                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6611                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6612                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6613                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6614                 }
6615                 if (r->domain_dn) {
6616                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6617                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6618                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6619                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_dn, ndr_charset_length(r->domain_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6620                 }
6621         }
6622         return NDR_ERR_SUCCESS;
6623 }
6624
6625 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerRequest1 *r)
6626 {
6627         uint32_t _ptr_server_dn;
6628         TALLOC_CTX *_mem_save_server_dn_0;
6629         uint32_t _ptr_domain_dn;
6630         TALLOC_CTX *_mem_save_domain_dn_0;
6631         if (ndr_flags & NDR_SCALARS) {
6632                 NDR_CHECK(ndr_pull_align(ndr, 5));
6633                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6634                 if (_ptr_server_dn) {
6635                         NDR_PULL_ALLOC(ndr, r->server_dn);
6636                 } else {
6637                         r->server_dn = NULL;
6638                 }
6639                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_dn));
6640                 if (_ptr_domain_dn) {
6641                         NDR_PULL_ALLOC(ndr, r->domain_dn);
6642                 } else {
6643                         r->domain_dn = NULL;
6644                 }
6645                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->commit));
6646                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6647         }
6648         if (ndr_flags & NDR_BUFFERS) {
6649                 if (r->server_dn) {
6650                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6651                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6652                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6653                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6654                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6655                                 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));
6656                         }
6657                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6658                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6659                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6660                 }
6661                 if (r->domain_dn) {
6662                         _mem_save_domain_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6663                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_dn, 0);
6664                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_dn));
6665                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_dn));
6666                         if (ndr_get_array_length(ndr, &r->domain_dn) > ndr_get_array_size(ndr, &r->domain_dn)) {
6667                                 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));
6668                         }
6669                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t)));
6670                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t), CH_UTF16));
6671                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_dn_0, 0);
6672                 }
6673         }
6674         return NDR_ERR_SUCCESS;
6675 }
6676
6677 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6678 {
6679         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerRequest1");
6680         ndr->depth++;
6681         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6682         ndr->depth++;
6683         if (r->server_dn) {
6684                 ndr_print_string(ndr, "server_dn", r->server_dn);
6685         }
6686         ndr->depth--;
6687         ndr_print_ptr(ndr, "domain_dn", r->domain_dn);
6688         ndr->depth++;
6689         if (r->domain_dn) {
6690                 ndr_print_string(ndr, "domain_dn", r->domain_dn);
6691         }
6692         ndr->depth--;
6693         ndr_print_uint32(ndr, "commit", r->commit);
6694         ndr->depth--;
6695 }
6696
6697 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerRequest *r)
6698 {
6699         if (ndr_flags & NDR_SCALARS) {
6700                 int level = ndr_push_get_switch_value(ndr, r);
6701                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6702                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6703                 switch (level) {
6704                         case 1: {
6705                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6706                         break; }
6707
6708                         default:
6709                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6710                 }
6711         }
6712         if (ndr_flags & NDR_BUFFERS) {
6713                 int level = ndr_push_get_switch_value(ndr, r);
6714                 switch (level) {
6715                         case 1:
6716                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6717                         break;
6718
6719                         default:
6720                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6721                 }
6722         }
6723         return NDR_ERR_SUCCESS;
6724 }
6725
6726 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerRequest *r)
6727 {
6728         int level;
6729         int32_t _level;
6730         level = ndr_pull_get_switch_value(ndr, r);
6731         if (ndr_flags & NDR_SCALARS) {
6732                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6733                 if (_level != level) {
6734                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6735                 }
6736                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6737                 switch (level) {
6738                         case 1: {
6739                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6740                         break; }
6741
6742                         default:
6743                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6744                 }
6745         }
6746         if (ndr_flags & NDR_BUFFERS) {
6747                 switch (level) {
6748                         case 1:
6749                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6750                         break;
6751
6752                         default:
6753                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6754                 }
6755         }
6756         return NDR_ERR_SUCCESS;
6757 }
6758
6759 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerRequest *r)
6760 {
6761         int level;
6762         level = ndr_print_get_switch_value(ndr, r);
6763         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerRequest");
6764         switch (level) {
6765                 case 1:
6766                         ndr_print_drsuapi_DsRemoveDSServerRequest1(ndr, "req1", &r->req1);
6767                 break;
6768
6769                 default:
6770                         ndr_print_bad_level(ndr, name, level);
6771         }
6772 }
6773
6774 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerResult1 *r)
6775 {
6776         if (ndr_flags & NDR_SCALARS) {
6777                 NDR_CHECK(ndr_push_align(ndr, 4));
6778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->last_dc_in_domain));
6779                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6780         }
6781         if (ndr_flags & NDR_BUFFERS) {
6782         }
6783         return NDR_ERR_SUCCESS;
6784 }
6785
6786 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerResult1 *r)
6787 {
6788         if (ndr_flags & NDR_SCALARS) {
6789                 NDR_CHECK(ndr_pull_align(ndr, 4));
6790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->last_dc_in_domain));
6791                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6792         }
6793         if (ndr_flags & NDR_BUFFERS) {
6794         }
6795         return NDR_ERR_SUCCESS;
6796 }
6797
6798 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerResult1 *r)
6799 {
6800         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerResult1");
6801         ndr->depth++;
6802         ndr_print_uint32(ndr, "last_dc_in_domain", r->last_dc_in_domain);
6803         ndr->depth--;
6804 }
6805
6806 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerResult *r)
6807 {
6808         if (ndr_flags & NDR_SCALARS) {
6809                 int level = ndr_push_get_switch_value(ndr, r);
6810                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6811                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6812                 switch (level) {
6813                         case 1: {
6814                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6815                         break; }
6816
6817                         default:
6818                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6819                 }
6820         }
6821         if (ndr_flags & NDR_BUFFERS) {
6822                 int level = ndr_push_get_switch_value(ndr, r);
6823                 switch (level) {
6824                         case 1:
6825                         break;
6826
6827                         default:
6828                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6829                 }
6830         }
6831         return NDR_ERR_SUCCESS;
6832 }
6833
6834 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerResult *r)
6835 {
6836         int level;
6837         int32_t _level;
6838         level = ndr_pull_get_switch_value(ndr, r);
6839         if (ndr_flags & NDR_SCALARS) {
6840                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6841                 if (_level != level) {
6842                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6843                 }
6844                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6845                 switch (level) {
6846                         case 1: {
6847                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6848                         break; }
6849
6850                         default:
6851                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6852                 }
6853         }
6854         if (ndr_flags & NDR_BUFFERS) {
6855                 switch (level) {
6856                         case 1:
6857                         break;
6858
6859                         default:
6860                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6861                 }
6862         }
6863         return NDR_ERR_SUCCESS;
6864 }
6865
6866 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerResult *r)
6867 {
6868         int level;
6869         level = ndr_print_get_switch_value(ndr, r);
6870         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerResult");
6871         switch (level) {
6872                 case 1:
6873                         ndr_print_drsuapi_DsRemoveDSServerResult1(ndr, "res1", &r->res1);
6874                 break;
6875
6876                 default:
6877                         ndr_print_bad_level(ndr, name, level);
6878         }
6879 }
6880
6881 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoRequest1 *r)
6882 {
6883         if (ndr_flags & NDR_SCALARS) {
6884                 NDR_CHECK(ndr_push_align(ndr, 5));
6885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
6886                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
6887                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6888         }
6889         if (ndr_flags & NDR_BUFFERS) {
6890                 if (r->domain_name) {
6891                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6892                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6893                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6894                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6895                 }
6896         }
6897         return NDR_ERR_SUCCESS;
6898 }
6899
6900 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoRequest1 *r)
6901 {
6902         uint32_t _ptr_domain_name;
6903         TALLOC_CTX *_mem_save_domain_name_0;
6904         if (ndr_flags & NDR_SCALARS) {
6905                 NDR_CHECK(ndr_pull_align(ndr, 5));
6906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
6907                 if (_ptr_domain_name) {
6908                         NDR_PULL_ALLOC(ndr, r->domain_name);
6909                 } else {
6910                         r->domain_name = NULL;
6911                 }
6912                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
6913                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6914         }
6915         if (ndr_flags & NDR_BUFFERS) {
6916                 if (r->domain_name) {
6917                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6918                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
6919                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
6920                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
6921                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
6922                                 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));
6923                         }
6924                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
6925                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
6926                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
6927                 }
6928         }
6929         return NDR_ERR_SUCCESS;
6930 }
6931
6932 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoRequest1 *r)
6933 {
6934         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoRequest1");
6935         ndr->depth++;
6936         ndr_print_ptr(ndr, "domain_name", r->domain_name);
6937         ndr->depth++;
6938         if (r->domain_name) {
6939                 ndr_print_string(ndr, "domain_name", r->domain_name);
6940         }
6941         ndr->depth--;
6942         ndr_print_int32(ndr, "level", r->level);
6943         ndr->depth--;
6944 }
6945
6946 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoRequest *r)
6947 {
6948         if (ndr_flags & NDR_SCALARS) {
6949                 int level = ndr_push_get_switch_value(ndr, r);
6950                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6951                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6952                 switch (level) {
6953                         case 1: {
6954                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6955                         break; }
6956
6957                         default:
6958                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6959                 }
6960         }
6961         if (ndr_flags & NDR_BUFFERS) {
6962                 int level = ndr_push_get_switch_value(ndr, r);
6963                 switch (level) {
6964                         case 1:
6965                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6966                         break;
6967
6968                         default:
6969                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6970                 }
6971         }
6972         return NDR_ERR_SUCCESS;
6973 }
6974
6975 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoRequest *r)
6976 {
6977         int level;
6978         int32_t _level;
6979         level = ndr_pull_get_switch_value(ndr, r);
6980         if (ndr_flags & NDR_SCALARS) {
6981                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6982                 if (_level != level) {
6983                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6984                 }
6985                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6986                 switch (level) {
6987                         case 1: {
6988                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6989                         break; }
6990
6991                         default:
6992                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6993                 }
6994         }
6995         if (ndr_flags & NDR_BUFFERS) {
6996                 switch (level) {
6997                         case 1:
6998                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6999                         break;
7000
7001                         default:
7002                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
7003                 }
7004         }
7005         return NDR_ERR_SUCCESS;
7006 }
7007
7008 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoRequest *r)
7009 {
7010         int level;
7011         level = ndr_print_get_switch_value(ndr, r);
7012         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoRequest");
7013         switch (level) {
7014                 case 1:
7015                         ndr_print_drsuapi_DsGetDCInfoRequest1(ndr, "req1", &r->req1);
7016                 break;
7017
7018                 default:
7019                         ndr_print_bad_level(ndr, name, level);
7020         }
7021 }
7022
7023 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo1 *r)
7024 {
7025         if (ndr_flags & NDR_SCALARS) {
7026                 NDR_CHECK(ndr_push_align(ndr, 5));
7027                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7028                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7029                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7034                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7035         }
7036         if (ndr_flags & NDR_BUFFERS) {
7037                 if (r->netbios_name) {
7038                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7039                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7040                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7041                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7042                 }
7043                 if (r->dns_name) {
7044                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7045                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7046                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7047                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7048                 }
7049                 if (r->site_name) {
7050                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7051                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7052                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7053                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7054                 }
7055                 if (r->computer_dn) {
7056                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7057                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7058                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7059                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7060                 }
7061                 if (r->server_dn) {
7062                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7063                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7064                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7065                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7066                 }
7067         }
7068         return NDR_ERR_SUCCESS;
7069 }
7070
7071 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo1 *r)
7072 {
7073         uint32_t _ptr_netbios_name;
7074         TALLOC_CTX *_mem_save_netbios_name_0;
7075         uint32_t _ptr_dns_name;
7076         TALLOC_CTX *_mem_save_dns_name_0;
7077         uint32_t _ptr_site_name;
7078         TALLOC_CTX *_mem_save_site_name_0;
7079         uint32_t _ptr_computer_dn;
7080         TALLOC_CTX *_mem_save_computer_dn_0;
7081         uint32_t _ptr_server_dn;
7082         TALLOC_CTX *_mem_save_server_dn_0;
7083         if (ndr_flags & NDR_SCALARS) {
7084                 NDR_CHECK(ndr_pull_align(ndr, 5));
7085                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7086                 if (_ptr_netbios_name) {
7087                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7088                 } else {
7089                         r->netbios_name = NULL;
7090                 }
7091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7092                 if (_ptr_dns_name) {
7093                         NDR_PULL_ALLOC(ndr, r->dns_name);
7094                 } else {
7095                         r->dns_name = NULL;
7096                 }
7097                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7098                 if (_ptr_site_name) {
7099                         NDR_PULL_ALLOC(ndr, r->site_name);
7100                 } else {
7101                         r->site_name = NULL;
7102                 }
7103                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7104                 if (_ptr_computer_dn) {
7105                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7106                 } else {
7107                         r->computer_dn = NULL;
7108                 }
7109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7110                 if (_ptr_server_dn) {
7111                         NDR_PULL_ALLOC(ndr, r->server_dn);
7112                 } else {
7113                         r->server_dn = NULL;
7114                 }
7115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7116                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7117                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7118         }
7119         if (ndr_flags & NDR_BUFFERS) {
7120                 if (r->netbios_name) {
7121                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7122                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7123                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7124                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7125                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7126                                 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));
7127                         }
7128                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7129                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7130                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7131                 }
7132                 if (r->dns_name) {
7133                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7134                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7135                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7136                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7137                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7138                                 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));
7139                         }
7140                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7141                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7142                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7143                 }
7144                 if (r->site_name) {
7145                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7146                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7147                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7148                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7149                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7150                                 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));
7151                         }
7152                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7153                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7154                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7155                 }
7156                 if (r->computer_dn) {
7157                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7158                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7159                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7160                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7161                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7162                                 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));
7163                         }
7164                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7165                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7166                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7167                 }
7168                 if (r->server_dn) {
7169                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7170                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7171                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7172                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7173                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7174                                 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));
7175                         }
7176                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7177                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7178                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7179                 }
7180         }
7181         return NDR_ERR_SUCCESS;
7182 }
7183
7184 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo1 *r)
7185 {
7186         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo1");
7187         ndr->depth++;
7188         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7189         ndr->depth++;
7190         if (r->netbios_name) {
7191                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7192         }
7193         ndr->depth--;
7194         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7195         ndr->depth++;
7196         if (r->dns_name) {
7197                 ndr_print_string(ndr, "dns_name", r->dns_name);
7198         }
7199         ndr->depth--;
7200         ndr_print_ptr(ndr, "site_name", r->site_name);
7201         ndr->depth++;
7202         if (r->site_name) {
7203                 ndr_print_string(ndr, "site_name", r->site_name);
7204         }
7205         ndr->depth--;
7206         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7207         ndr->depth++;
7208         if (r->computer_dn) {
7209                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7210         }
7211         ndr->depth--;
7212         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7213         ndr->depth++;
7214         if (r->server_dn) {
7215                 ndr_print_string(ndr, "server_dn", r->server_dn);
7216         }
7217         ndr->depth--;
7218         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7219         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7220         ndr->depth--;
7221 }
7222
7223 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr1 *r)
7224 {
7225         uint32_t cntr_array_1;
7226         if (ndr_flags & NDR_SCALARS) {
7227                 NDR_CHECK(ndr_push_align(ndr, 5));
7228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7229                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7230                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7231         }
7232         if (ndr_flags & NDR_BUFFERS) {
7233                 if (r->array) {
7234                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7235                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7236                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7237                         }
7238                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7239                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7240                         }
7241                 }
7242         }
7243         return NDR_ERR_SUCCESS;
7244 }
7245
7246 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr1 *r)
7247 {
7248         uint32_t _ptr_array;
7249         uint32_t cntr_array_1;
7250         TALLOC_CTX *_mem_save_array_0;
7251         TALLOC_CTX *_mem_save_array_1;
7252         if (ndr_flags & NDR_SCALARS) {
7253                 NDR_CHECK(ndr_pull_align(ndr, 5));
7254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7255                 if (r->count > 10000) {
7256                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7257                 }
7258                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7259                 if (_ptr_array) {
7260                         NDR_PULL_ALLOC(ndr, r->array);
7261                 } else {
7262                         r->array = NULL;
7263                 }
7264                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7265         }
7266         if (ndr_flags & NDR_BUFFERS) {
7267                 if (r->array) {
7268                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7269                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7270                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7271                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7272                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7273                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7274                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7275                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7276                         }
7277                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7278                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7279                         }
7280                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7281                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7282                 }
7283                 if (r->array) {
7284                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7285                 }
7286         }
7287         return NDR_ERR_SUCCESS;
7288 }
7289
7290 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr1 *r)
7291 {
7292         uint32_t cntr_array_1;
7293         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr1");
7294         ndr->depth++;
7295         ndr_print_uint32(ndr, "count", r->count);
7296         ndr_print_ptr(ndr, "array", r->array);
7297         ndr->depth++;
7298         if (r->array) {
7299                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7300                 ndr->depth++;
7301                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7302                         char *idx_1=NULL;
7303                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7304                                 ndr_print_drsuapi_DsGetDCInfo1(ndr, "array", &r->array[cntr_array_1]);
7305                                 free(idx_1);
7306                         }
7307                 }
7308                 ndr->depth--;
7309         }
7310         ndr->depth--;
7311         ndr->depth--;
7312 }
7313
7314 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo2 *r)
7315 {
7316         if (ndr_flags & NDR_SCALARS) {
7317                 NDR_CHECK(ndr_push_align(ndr, 5));
7318                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7319                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7320                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7321                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7322                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7323                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7324                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7328                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7329                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7330                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7331                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7332                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7333         }
7334         if (ndr_flags & NDR_BUFFERS) {
7335                 if (r->netbios_name) {
7336                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7337                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7338                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7339                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7340                 }
7341                 if (r->dns_name) {
7342                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7343                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7344                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7345                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7346                 }
7347                 if (r->site_name) {
7348                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7349                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7350                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7351                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7352                 }
7353                 if (r->site_dn) {
7354                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7355                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7356                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7357                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7358                 }
7359                 if (r->computer_dn) {
7360                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7361                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7362                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7363                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7364                 }
7365                 if (r->server_dn) {
7366                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7367                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7368                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7369                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7370                 }
7371                 if (r->ntds_dn) {
7372                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7373                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7374                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7375                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7376                 }
7377         }
7378         return NDR_ERR_SUCCESS;
7379 }
7380
7381 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo2 *r)
7382 {
7383         uint32_t _ptr_netbios_name;
7384         TALLOC_CTX *_mem_save_netbios_name_0;
7385         uint32_t _ptr_dns_name;
7386         TALLOC_CTX *_mem_save_dns_name_0;
7387         uint32_t _ptr_site_name;
7388         TALLOC_CTX *_mem_save_site_name_0;
7389         uint32_t _ptr_site_dn;
7390         TALLOC_CTX *_mem_save_site_dn_0;
7391         uint32_t _ptr_computer_dn;
7392         TALLOC_CTX *_mem_save_computer_dn_0;
7393         uint32_t _ptr_server_dn;
7394         TALLOC_CTX *_mem_save_server_dn_0;
7395         uint32_t _ptr_ntds_dn;
7396         TALLOC_CTX *_mem_save_ntds_dn_0;
7397         if (ndr_flags & NDR_SCALARS) {
7398                 NDR_CHECK(ndr_pull_align(ndr, 5));
7399                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7400                 if (_ptr_netbios_name) {
7401                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7402                 } else {
7403                         r->netbios_name = NULL;
7404                 }
7405                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7406                 if (_ptr_dns_name) {
7407                         NDR_PULL_ALLOC(ndr, r->dns_name);
7408                 } else {
7409                         r->dns_name = NULL;
7410                 }
7411                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7412                 if (_ptr_site_name) {
7413                         NDR_PULL_ALLOC(ndr, r->site_name);
7414                 } else {
7415                         r->site_name = NULL;
7416                 }
7417                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7418                 if (_ptr_site_dn) {
7419                         NDR_PULL_ALLOC(ndr, r->site_dn);
7420                 } else {
7421                         r->site_dn = NULL;
7422                 }
7423                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7424                 if (_ptr_computer_dn) {
7425                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7426                 } else {
7427                         r->computer_dn = NULL;
7428                 }
7429                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7430                 if (_ptr_server_dn) {
7431                         NDR_PULL_ALLOC(ndr, r->server_dn);
7432                 } else {
7433                         r->server_dn = NULL;
7434                 }
7435                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7436                 if (_ptr_ntds_dn) {
7437                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7438                 } else {
7439                         r->ntds_dn = NULL;
7440                 }
7441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7444                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7445                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7446                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7447                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7448                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7449         }
7450         if (ndr_flags & NDR_BUFFERS) {
7451                 if (r->netbios_name) {
7452                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7453                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7454                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7455                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7456                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7457                                 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));
7458                         }
7459                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7460                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7461                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7462                 }
7463                 if (r->dns_name) {
7464                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7465                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7466                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7467                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7468                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7469                                 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));
7470                         }
7471                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7472                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7473                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7474                 }
7475                 if (r->site_name) {
7476                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7477                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7478                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7479                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7480                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7481                                 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));
7482                         }
7483                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7484                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7485                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7486                 }
7487                 if (r->site_dn) {
7488                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7489                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7490                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7491                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7492                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7493                                 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));
7494                         }
7495                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7496                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7497                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7498                 }
7499                 if (r->computer_dn) {
7500                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7501                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7502                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7503                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7504                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7505                                 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));
7506                         }
7507                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7508                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7509                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7510                 }
7511                 if (r->server_dn) {
7512                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7513                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7514                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7515                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7516                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7517                                 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));
7518                         }
7519                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7520                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7521                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7522                 }
7523                 if (r->ntds_dn) {
7524                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7525                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7526                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7527                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7528                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7529                                 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));
7530                         }
7531                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7532                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7533                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7534                 }
7535         }
7536         return NDR_ERR_SUCCESS;
7537 }
7538
7539 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo2 *r)
7540 {
7541         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo2");
7542         ndr->depth++;
7543         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7544         ndr->depth++;
7545         if (r->netbios_name) {
7546                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7547         }
7548         ndr->depth--;
7549         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7550         ndr->depth++;
7551         if (r->dns_name) {
7552                 ndr_print_string(ndr, "dns_name", r->dns_name);
7553         }
7554         ndr->depth--;
7555         ndr_print_ptr(ndr, "site_name", r->site_name);
7556         ndr->depth++;
7557         if (r->site_name) {
7558                 ndr_print_string(ndr, "site_name", r->site_name);
7559         }
7560         ndr->depth--;
7561         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7562         ndr->depth++;
7563         if (r->site_dn) {
7564                 ndr_print_string(ndr, "site_dn", r->site_dn);
7565         }
7566         ndr->depth--;
7567         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7568         ndr->depth++;
7569         if (r->computer_dn) {
7570                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7571         }
7572         ndr->depth--;
7573         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7574         ndr->depth++;
7575         if (r->server_dn) {
7576                 ndr_print_string(ndr, "server_dn", r->server_dn);
7577         }
7578         ndr->depth--;
7579         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7580         ndr->depth++;
7581         if (r->ntds_dn) {
7582                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7583         }
7584         ndr->depth--;
7585         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7586         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7587         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7588         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7589         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7590         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7591         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7592         ndr->depth--;
7593 }
7594
7595 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr2 *r)
7596 {
7597         uint32_t cntr_array_1;
7598         if (ndr_flags & NDR_SCALARS) {
7599                 NDR_CHECK(ndr_push_align(ndr, 5));
7600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7601                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7602                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7603         }
7604         if (ndr_flags & NDR_BUFFERS) {
7605                 if (r->array) {
7606                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7607                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7608                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7609                         }
7610                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7611                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7612                         }
7613                 }
7614         }
7615         return NDR_ERR_SUCCESS;
7616 }
7617
7618 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr2 *r)
7619 {
7620         uint32_t _ptr_array;
7621         uint32_t cntr_array_1;
7622         TALLOC_CTX *_mem_save_array_0;
7623         TALLOC_CTX *_mem_save_array_1;
7624         if (ndr_flags & NDR_SCALARS) {
7625                 NDR_CHECK(ndr_pull_align(ndr, 5));
7626                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7627                 if (r->count > 10000) {
7628                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7629                 }
7630                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7631                 if (_ptr_array) {
7632                         NDR_PULL_ALLOC(ndr, r->array);
7633                 } else {
7634                         r->array = NULL;
7635                 }
7636                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7637         }
7638         if (ndr_flags & NDR_BUFFERS) {
7639                 if (r->array) {
7640                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7641                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7642                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7643                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7644                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7645                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7646                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7647                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7648                         }
7649                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7650                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7651                         }
7652                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7653                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7654                 }
7655                 if (r->array) {
7656                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7657                 }
7658         }
7659         return NDR_ERR_SUCCESS;
7660 }
7661
7662 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr2 *r)
7663 {
7664         uint32_t cntr_array_1;
7665         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr2");
7666         ndr->depth++;
7667         ndr_print_uint32(ndr, "count", r->count);
7668         ndr_print_ptr(ndr, "array", r->array);
7669         ndr->depth++;
7670         if (r->array) {
7671                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7672                 ndr->depth++;
7673                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7674                         char *idx_1=NULL;
7675                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7676                                 ndr_print_drsuapi_DsGetDCInfo2(ndr, "array", &r->array[cntr_array_1]);
7677                                 free(idx_1);
7678                         }
7679                 }
7680                 ndr->depth--;
7681         }
7682         ndr->depth--;
7683         ndr->depth--;
7684 }
7685
7686 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo3 *r)
7687 {
7688         if (ndr_flags & NDR_SCALARS) {
7689                 NDR_CHECK(ndr_push_align(ndr, 5));
7690                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7691                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7692                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7693                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7694                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7695                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7696                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7697                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_rodc));
7701                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7702                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7703                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7704                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7705                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7706         }
7707         if (ndr_flags & NDR_BUFFERS) {
7708                 if (r->netbios_name) {
7709                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7710                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7711                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7712                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7713                 }
7714                 if (r->dns_name) {
7715                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7716                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7717                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7718                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7719                 }
7720                 if (r->site_name) {
7721                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7722                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7723                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7724                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7725                 }
7726                 if (r->site_dn) {
7727                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7728                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7729                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7730                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7731                 }
7732                 if (r->computer_dn) {
7733                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7734                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7735                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7736                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7737                 }
7738                 if (r->server_dn) {
7739                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7740                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7741                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7742                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7743                 }
7744                 if (r->ntds_dn) {
7745                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7746                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7747                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7748                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7749                 }
7750         }
7751         return NDR_ERR_SUCCESS;
7752 }
7753
7754 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo3 *r)
7755 {
7756         uint32_t _ptr_netbios_name;
7757         TALLOC_CTX *_mem_save_netbios_name_0;
7758         uint32_t _ptr_dns_name;
7759         TALLOC_CTX *_mem_save_dns_name_0;
7760         uint32_t _ptr_site_name;
7761         TALLOC_CTX *_mem_save_site_name_0;
7762         uint32_t _ptr_site_dn;
7763         TALLOC_CTX *_mem_save_site_dn_0;
7764         uint32_t _ptr_computer_dn;
7765         TALLOC_CTX *_mem_save_computer_dn_0;
7766         uint32_t _ptr_server_dn;
7767         TALLOC_CTX *_mem_save_server_dn_0;
7768         uint32_t _ptr_ntds_dn;
7769         TALLOC_CTX *_mem_save_ntds_dn_0;
7770         if (ndr_flags & NDR_SCALARS) {
7771                 NDR_CHECK(ndr_pull_align(ndr, 5));
7772                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7773                 if (_ptr_netbios_name) {
7774                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7775                 } else {
7776                         r->netbios_name = NULL;
7777                 }
7778                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7779                 if (_ptr_dns_name) {
7780                         NDR_PULL_ALLOC(ndr, r->dns_name);
7781                 } else {
7782                         r->dns_name = NULL;
7783                 }
7784                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7785                 if (_ptr_site_name) {
7786                         NDR_PULL_ALLOC(ndr, r->site_name);
7787                 } else {
7788                         r->site_name = NULL;
7789                 }
7790                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7791                 if (_ptr_site_dn) {
7792                         NDR_PULL_ALLOC(ndr, r->site_dn);
7793                 } else {
7794                         r->site_dn = NULL;
7795                 }
7796                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7797                 if (_ptr_computer_dn) {
7798                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7799                 } else {
7800                         r->computer_dn = NULL;
7801                 }
7802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7803                 if (_ptr_server_dn) {
7804                         NDR_PULL_ALLOC(ndr, r->server_dn);
7805                 } else {
7806                         r->server_dn = NULL;
7807                 }
7808                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7809                 if (_ptr_ntds_dn) {
7810                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7811                 } else {
7812                         r->ntds_dn = NULL;
7813                 }
7814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7817                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_rodc));
7818                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7819                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7820                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7821                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7822                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7823         }
7824         if (ndr_flags & NDR_BUFFERS) {
7825                 if (r->netbios_name) {
7826                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7827                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7828                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7829                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7830                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7831                                 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));
7832                         }
7833                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7834                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7836                 }
7837                 if (r->dns_name) {
7838                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7839                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7840                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7841                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7842                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7843                                 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));
7844                         }
7845                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7846                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7847                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7848                 }
7849                 if (r->site_name) {
7850                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7851                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7852                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7853                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7854                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7855                                 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));
7856                         }
7857                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7858                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7859                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7860                 }
7861                 if (r->site_dn) {
7862                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7863                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7864                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7865                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7866                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7867                                 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));
7868                         }
7869                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7870                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7871                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7872                 }
7873                 if (r->computer_dn) {
7874                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7875                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7876                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7877                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7878                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7879                                 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));
7880                         }
7881                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7882                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7883                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7884                 }
7885                 if (r->server_dn) {
7886                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7887                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7888                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7889                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7890                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7891                                 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));
7892                         }
7893                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7894                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7895                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7896                 }
7897                 if (r->ntds_dn) {
7898                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7899                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7900                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7901                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7902                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7903                                 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));
7904                         }
7905                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7906                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7907                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7908                 }
7909         }
7910         return NDR_ERR_SUCCESS;
7911 }
7912
7913 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo3 *r)
7914 {
7915         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo3");
7916         ndr->depth++;
7917         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7918         ndr->depth++;
7919         if (r->netbios_name) {
7920                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7921         }
7922         ndr->depth--;
7923         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7924         ndr->depth++;
7925         if (r->dns_name) {
7926                 ndr_print_string(ndr, "dns_name", r->dns_name);
7927         }
7928         ndr->depth--;
7929         ndr_print_ptr(ndr, "site_name", r->site_name);
7930         ndr->depth++;
7931         if (r->site_name) {
7932                 ndr_print_string(ndr, "site_name", r->site_name);
7933         }
7934         ndr->depth--;
7935         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7936         ndr->depth++;
7937         if (r->site_dn) {
7938                 ndr_print_string(ndr, "site_dn", r->site_dn);
7939         }
7940         ndr->depth--;
7941         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7942         ndr->depth++;
7943         if (r->computer_dn) {
7944                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7945         }
7946         ndr->depth--;
7947         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7948         ndr->depth++;
7949         if (r->server_dn) {
7950                 ndr_print_string(ndr, "server_dn", r->server_dn);
7951         }
7952         ndr->depth--;
7953         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7954         ndr->depth++;
7955         if (r->ntds_dn) {
7956                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7957         }
7958         ndr->depth--;
7959         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7960         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7961         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7962         ndr_print_uint32(ndr, "is_rodc", r->is_rodc);
7963         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7964         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7965         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7966         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7967         ndr->depth--;
7968 }
7969
7970 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr3 *r)
7971 {
7972         uint32_t cntr_array_1;
7973         if (ndr_flags & NDR_SCALARS) {
7974                 NDR_CHECK(ndr_push_align(ndr, 5));
7975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7976                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7977                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7978         }
7979         if (ndr_flags & NDR_BUFFERS) {
7980                 if (r->array) {
7981                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7982                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7983                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7984                         }
7985                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7986                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7987                         }
7988                 }
7989         }
7990         return NDR_ERR_SUCCESS;
7991 }
7992
7993 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr3 *r)
7994 {
7995         uint32_t _ptr_array;
7996         uint32_t cntr_array_1;
7997         TALLOC_CTX *_mem_save_array_0;
7998         TALLOC_CTX *_mem_save_array_1;
7999         if (ndr_flags & NDR_SCALARS) {
8000                 NDR_CHECK(ndr_pull_align(ndr, 5));
8001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8002                 if (r->count > 10000) {
8003                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8004                 }
8005                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
8006                 if (_ptr_array) {
8007                         NDR_PULL_ALLOC(ndr, r->array);
8008                 } else {
8009                         r->array = NULL;
8010                 }
8011                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8012         }
8013         if (ndr_flags & NDR_BUFFERS) {
8014                 if (r->array) {
8015                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
8016                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8017                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
8018                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
8019                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
8020                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8021                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8022                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8023                         }
8024                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8025                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8026                         }
8027                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
8028                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
8029                 }
8030                 if (r->array) {
8031                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
8032                 }
8033         }
8034         return NDR_ERR_SUCCESS;
8035 }
8036
8037 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr3 *r)
8038 {
8039         uint32_t cntr_array_1;
8040         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr3");
8041         ndr->depth++;
8042         ndr_print_uint32(ndr, "count", r->count);
8043         ndr_print_ptr(ndr, "array", r->array);
8044         ndr->depth++;
8045         if (r->array) {
8046                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
8047                 ndr->depth++;
8048                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
8049                         char *idx_1=NULL;
8050                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8051                                 ndr_print_drsuapi_DsGetDCInfo3(ndr, "array", &r->array[cntr_array_1]);
8052                                 free(idx_1);
8053                         }
8054                 }
8055                 ndr->depth--;
8056         }
8057         ndr->depth--;
8058         ndr->depth--;
8059 }
8060
8061 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnection01 *r)
8062 {
8063         if (ndr_flags & NDR_SCALARS) {
8064                 NDR_CHECK(ndr_push_align(ndr, 5));
8065                 {
8066                         uint32_t _flags_save_ipv4address = ndr->flags;
8067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
8068                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
8069                         ndr->flags = _flags_save_ipv4address;
8070                 }
8071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connection_time));
8073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
8074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
8075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
8076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
8077                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8078         }
8079         if (ndr_flags & NDR_BUFFERS) {
8080                 if (r->client_account) {
8081                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
8082                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8083                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
8084                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_account, ndr_charset_length(r->client_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8085                 }
8086         }
8087         return NDR_ERR_SUCCESS;
8088 }
8089
8090 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnection01 *r)
8091 {
8092         uint32_t _ptr_client_account;
8093         TALLOC_CTX *_mem_save_client_account_0;
8094         if (ndr_flags & NDR_SCALARS) {
8095                 NDR_CHECK(ndr_pull_align(ndr, 5));
8096                 {
8097                         uint32_t _flags_save_ipv4address = ndr->flags;
8098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
8099                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
8100                         ndr->flags = _flags_save_ipv4address;
8101                 }
8102                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8103                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connection_time));
8104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
8105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
8106                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
8107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_account));
8108                 if (_ptr_client_account) {
8109                         NDR_PULL_ALLOC(ndr, r->client_account);
8110                 } else {
8111                         r->client_account = NULL;
8112                 }
8113                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8114         }
8115         if (ndr_flags & NDR_BUFFERS) {
8116                 if (r->client_account) {
8117                         _mem_save_client_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8118                         NDR_PULL_SET_MEM_CTX(ndr, r->client_account, 0);
8119                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_account));
8120                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_account));
8121                         if (ndr_get_array_length(ndr, &r->client_account) > ndr_get_array_size(ndr, &r->client_account)) {
8122                                 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));
8123                         }
8124                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t)));
8125                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t), CH_UTF16));
8126                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_account_0, 0);
8127                 }
8128         }
8129         return NDR_ERR_SUCCESS;
8130 }
8131
8132 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnection01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnection01 *r)
8133 {
8134         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnection01");
8135         ndr->depth++;
8136         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
8137         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8138         ndr_print_uint32(ndr, "connection_time", r->connection_time);
8139         ndr_print_uint32(ndr, "unknown4", r->unknown4);
8140         ndr_print_uint32(ndr, "unknown5", r->unknown5);
8141         ndr_print_uint32(ndr, "unknown6", r->unknown6);
8142         ndr_print_ptr(ndr, "client_account", r->client_account);
8143         ndr->depth++;
8144         if (r->client_account) {
8145                 ndr_print_string(ndr, "client_account", r->client_account);
8146         }
8147         ndr->depth--;
8148         ndr->depth--;
8149 }
8150
8151 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8152 {
8153         uint32_t cntr_array_1;
8154         if (ndr_flags & NDR_SCALARS) {
8155                 NDR_CHECK(ndr_push_align(ndr, 5));
8156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8157                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
8158                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8159         }
8160         if (ndr_flags & NDR_BUFFERS) {
8161                 if (r->array) {
8162                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
8163                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8164                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8165                         }
8166                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8167                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8168                         }
8169                 }
8170         }
8171         return NDR_ERR_SUCCESS;
8172 }
8173
8174 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnectionCtr01 *r)
8175 {
8176         uint32_t _ptr_array;
8177         uint32_t cntr_array_1;
8178         TALLOC_CTX *_mem_save_array_0;
8179         TALLOC_CTX *_mem_save_array_1;
8180         if (ndr_flags & NDR_SCALARS) {
8181                 NDR_CHECK(ndr_pull_align(ndr, 5));
8182                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8183                 if (r->count > 10000) {
8184                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8185                 }
8186                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
8187                 if (_ptr_array) {
8188                         NDR_PULL_ALLOC(ndr, r->array);
8189                 } else {
8190                         r->array = NULL;
8191                 }
8192                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8193         }
8194         if (ndr_flags & NDR_BUFFERS) {
8195                 if (r->array) {
8196                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
8197                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8198                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
8199                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
8200                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
8201                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8202                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8203                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8204                         }
8205                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8206                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8207                         }
8208                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
8209                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
8210                 }
8211                 if (r->array) {
8212                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
8213                 }
8214         }
8215         return NDR_ERR_SUCCESS;
8216 }
8217
8218 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnectionCtr01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8219 {
8220         uint32_t cntr_array_1;
8221         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnectionCtr01");
8222         ndr->depth++;
8223         ndr_print_uint32(ndr, "count", r->count);
8224         ndr_print_ptr(ndr, "array", r->array);
8225         ndr->depth++;
8226         if (r->array) {
8227                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
8228                 ndr->depth++;
8229                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
8230                         char *idx_1=NULL;
8231                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8232                                 ndr_print_drsuapi_DsGetDCConnection01(ndr, "array", &r->array[cntr_array_1]);
8233                                 free(idx_1);
8234                         }
8235                 }
8236                 ndr->depth--;
8237         }
8238         ndr->depth--;
8239         ndr->depth--;
8240 }
8241
8242 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoCtr *r)
8243 {
8244         if (ndr_flags & NDR_SCALARS) {
8245                 int level = ndr_push_get_switch_value(ndr, r);
8246                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8247                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8248                 switch (level) {
8249                         case DRSUAPI_DC_INFO_CTR_1: {
8250                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8251                         break; }
8252
8253                         case DRSUAPI_DC_INFO_CTR_2: {
8254                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8255                         break; }
8256
8257                         case DRSUAPI_DC_INFO_CTR_3: {
8258                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8259                         break; }
8260
8261                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8262                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8263                         break; }
8264
8265                         default:
8266                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8267                 }
8268         }
8269         if (ndr_flags & NDR_BUFFERS) {
8270                 int level = ndr_push_get_switch_value(ndr, r);
8271                 switch (level) {
8272                         case DRSUAPI_DC_INFO_CTR_1:
8273                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8274                         break;
8275
8276                         case DRSUAPI_DC_INFO_CTR_2:
8277                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8278                         break;
8279
8280                         case DRSUAPI_DC_INFO_CTR_3:
8281                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8282                         break;
8283
8284                         case DRSUAPI_DC_CONNECTION_CTR_01:
8285                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8286                         break;
8287
8288                         default:
8289                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8290                 }
8291         }
8292         return NDR_ERR_SUCCESS;
8293 }
8294
8295 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoCtr *r)
8296 {
8297         int level;
8298         int32_t _level;
8299         level = ndr_pull_get_switch_value(ndr, r);
8300         if (ndr_flags & NDR_SCALARS) {
8301                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8302                 if (_level != level) {
8303                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8304                 }
8305                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8306                 switch (level) {
8307                         case DRSUAPI_DC_INFO_CTR_1: {
8308                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8309                         break; }
8310
8311                         case DRSUAPI_DC_INFO_CTR_2: {
8312                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8313                         break; }
8314
8315                         case DRSUAPI_DC_INFO_CTR_3: {
8316                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8317                         break; }
8318
8319                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8320                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8321                         break; }
8322
8323                         default:
8324                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8325                 }
8326         }
8327         if (ndr_flags & NDR_BUFFERS) {
8328                 switch (level) {
8329                         case DRSUAPI_DC_INFO_CTR_1:
8330                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8331                         break;
8332
8333                         case DRSUAPI_DC_INFO_CTR_2:
8334                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8335                         break;
8336
8337                         case DRSUAPI_DC_INFO_CTR_3:
8338                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8339                         break;
8340
8341                         case DRSUAPI_DC_CONNECTION_CTR_01:
8342                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8343                         break;
8344
8345                         default:
8346                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8347                 }
8348         }
8349         return NDR_ERR_SUCCESS;
8350 }
8351
8352 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoCtr *r)
8353 {
8354         int level;
8355         level = ndr_print_get_switch_value(ndr, r);
8356         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoCtr");
8357         switch (level) {
8358                 case DRSUAPI_DC_INFO_CTR_1:
8359                         ndr_print_drsuapi_DsGetDCInfoCtr1(ndr, "ctr1", &r->ctr1);
8360                 break;
8361
8362                 case DRSUAPI_DC_INFO_CTR_2:
8363                         ndr_print_drsuapi_DsGetDCInfoCtr2(ndr, "ctr2", &r->ctr2);
8364                 break;
8365
8366                 case DRSUAPI_DC_INFO_CTR_3:
8367                         ndr_print_drsuapi_DsGetDCInfoCtr3(ndr, "ctr3", &r->ctr3);
8368                 break;
8369
8370                 case DRSUAPI_DC_CONNECTION_CTR_01:
8371                         ndr_print_drsuapi_DsGetDCConnectionCtr01(ndr, "ctr01", &r->ctr01);
8372                 break;
8373
8374                 default:
8375                         ndr_print_bad_level(ndr, name, level);
8376         }
8377 }
8378
8379 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItem *r)
8380 {
8381         if (ndr_flags & NDR_SCALARS) {
8382                 NDR_CHECK(ndr_push_align(ndr, 5));
8383                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
8384                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8385                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8386         }
8387         if (ndr_flags & NDR_BUFFERS) {
8388                 if (r->next_object) {
8389                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8390                 }
8391                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8392         }
8393         return NDR_ERR_SUCCESS;
8394 }
8395
8396 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItem *r)
8397 {
8398         uint32_t _ptr_next_object;
8399         TALLOC_CTX *_mem_save_next_object_0;
8400         if (ndr_flags & NDR_SCALARS) {
8401                 NDR_CHECK(ndr_pull_align(ndr, 5));
8402                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
8403                 if (_ptr_next_object) {
8404                         NDR_PULL_ALLOC(ndr, r->next_object);
8405                 } else {
8406                         r->next_object = NULL;
8407                 }
8408                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8409                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8410         }
8411         if (ndr_flags & NDR_BUFFERS) {
8412                 if (r->next_object) {
8413                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
8414                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
8415                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8416                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
8417                 }
8418                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8419         }
8420         return NDR_ERR_SUCCESS;
8421 }
8422
8423 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryRequest2 *r)
8424 {
8425         if (ndr_flags & NDR_SCALARS) {
8426                 NDR_CHECK(ndr_push_align(ndr, 5));
8427                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8428                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8429         }
8430         if (ndr_flags & NDR_BUFFERS) {
8431                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8432         }
8433         return NDR_ERR_SUCCESS;
8434 }
8435
8436 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryRequest2 *r)
8437 {
8438         if (ndr_flags & NDR_SCALARS) {
8439                 NDR_CHECK(ndr_pull_align(ndr, 5));
8440                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8441                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8442         }
8443         if (ndr_flags & NDR_BUFFERS) {
8444                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8445         }
8446         return NDR_ERR_SUCCESS;
8447 }
8448
8449 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryRequest2 *r)
8450 {
8451         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryRequest2");
8452         ndr->depth++;
8453         ndr_print_drsuapi_DsReplicaObjectListItem(ndr, "first_object", &r->first_object);
8454         ndr->depth--;
8455 }
8456
8457 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryRequest *r)
8458 {
8459         if (ndr_flags & NDR_SCALARS) {
8460                 int level = ndr_push_get_switch_value(ndr, r);
8461                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8462                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8463                 switch (level) {
8464                         case 2: {
8465                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8466                         break; }
8467
8468                         default:
8469                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8470                 }
8471         }
8472         if (ndr_flags & NDR_BUFFERS) {
8473                 int level = ndr_push_get_switch_value(ndr, r);
8474                 switch (level) {
8475                         case 2:
8476                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8477                         break;
8478
8479                         default:
8480                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8481                 }
8482         }
8483         return NDR_ERR_SUCCESS;
8484 }
8485
8486 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryRequest *r)
8487 {
8488         int level;
8489         int32_t _level;
8490         level = ndr_pull_get_switch_value(ndr, r);
8491         if (ndr_flags & NDR_SCALARS) {
8492                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8493                 if (_level != level) {
8494                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8495                 }
8496                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8497                 switch (level) {
8498                         case 2: {
8499                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8500                         break; }
8501
8502                         default:
8503                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8504                 }
8505         }
8506         if (ndr_flags & NDR_BUFFERS) {
8507                 switch (level) {
8508                         case 2:
8509                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8510                         break;
8511
8512                         default:
8513                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8514                 }
8515         }
8516         return NDR_ERR_SUCCESS;
8517 }
8518
8519 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryRequest *r)
8520 {
8521         int level;
8522         level = ndr_print_get_switch_value(ndr, r);
8523         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryRequest");
8524         switch (level) {
8525                 case 2:
8526                         ndr_print_drsuapi_DsAddEntryRequest2(ndr, "req2", &r->req2);
8527                 break;
8528
8529                 default:
8530                         ndr_print_bad_level(ndr, name, level);
8531         }
8532 }
8533
8534 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfoX *r)
8535 {
8536         if (ndr_flags & NDR_SCALARS) {
8537                 NDR_CHECK(ndr_push_align(ndr, 4));
8538                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8539                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8541                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
8542                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8543         }
8544         if (ndr_flags & NDR_BUFFERS) {
8545         }
8546         return NDR_ERR_SUCCESS;
8547 }
8548
8549 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfoX *r)
8550 {
8551         if (ndr_flags & NDR_SCALARS) {
8552                 NDR_CHECK(ndr_pull_align(ndr, 4));
8553                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8554                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8556                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
8557                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8558         }
8559         if (ndr_flags & NDR_BUFFERS) {
8560         }
8561         return NDR_ERR_SUCCESS;
8562 }
8563
8564 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfoX(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfoX *r)
8565 {
8566         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfoX");
8567         ndr->depth++;
8568         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8569         ndr_print_WERROR(ndr, "status", r->status);
8570         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8571         ndr_print_uint16(ndr, "unknown3", r->unknown3);
8572         ndr->depth--;
8573 }
8574
8575 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8576 {
8577         if (ndr_flags & NDR_SCALARS) {
8578                 NDR_CHECK(ndr_push_align(ndr, 5));
8579                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8580                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
8581                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8582         }
8583         if (ndr_flags & NDR_BUFFERS) {
8584                 if (r->data) {
8585                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size));
8586                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
8587                 }
8588         }
8589         return NDR_ERR_SUCCESS;
8590 }
8591
8592 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8593 {
8594         uint32_t _ptr_data;
8595         TALLOC_CTX *_mem_save_data_0;
8596         if (ndr_flags & NDR_SCALARS) {
8597                 NDR_CHECK(ndr_pull_align(ndr, 5));
8598                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8599                 if (r->size > 10485760) {
8600                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8601                 }
8602                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
8603                 if (_ptr_data) {
8604                         NDR_PULL_ALLOC(ndr, r->data);
8605                 } else {
8606                         r->data = NULL;
8607                 }
8608                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8609         }
8610         if (ndr_flags & NDR_BUFFERS) {
8611                 if (r->data) {
8612                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
8613                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
8614                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
8615                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
8616                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
8617                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
8618                 }
8619                 if (r->data) {
8620                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
8621                 }
8622         }
8623         return NDR_ERR_SUCCESS;
8624 }
8625
8626 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8627 {
8628         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraErrorBuffer");
8629         ndr->depth++;
8630         ndr_print_uint32(ndr, "size", r->size);
8631         ndr_print_ptr(ndr, "data", r->data);
8632         ndr->depth++;
8633         if (r->data) {
8634                 ndr_print_array_uint8(ndr, "data", r->data, r->size);
8635         }
8636         ndr->depth--;
8637         ndr->depth--;
8638 }
8639
8640 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraError1 *r)
8641 {
8642         if (ndr_flags & NDR_SCALARS) {
8643                 NDR_CHECK(ndr_push_align(ndr, 5));
8644                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8645                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
8646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8647                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8648                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8649         }
8650         if (ndr_flags & NDR_BUFFERS) {
8651                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8652         }
8653         return NDR_ERR_SUCCESS;
8654 }
8655
8656 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraError1 *r)
8657 {
8658         if (ndr_flags & NDR_SCALARS) {
8659                 NDR_CHECK(ndr_pull_align(ndr, 5));
8660                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8661                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
8662                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8663                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8664                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8665         }
8666         if (ndr_flags & NDR_BUFFERS) {
8667                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8668         }
8669         return NDR_ERR_SUCCESS;
8670 }
8671
8672 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraError1 *r)
8673 {
8674         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraError1");
8675         ndr->depth++;
8676         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8677         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
8678         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8679         ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(ndr, "buffer", &r->buffer);
8680         ndr->depth--;
8681 }
8682
8683 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8684 {
8685         if (ndr_flags & NDR_SCALARS) {
8686                 NDR_CHECK(ndr_push_align(ndr, 5));
8687                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
8688                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8689                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8690         }
8691         if (ndr_flags & NDR_BUFFERS) {
8692                 if (r->next) {
8693                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8694                 }
8695                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8696         }
8697         return NDR_ERR_SUCCESS;
8698 }
8699
8700 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorListItem1 *r)
8701 {
8702         uint32_t _ptr_next;
8703         TALLOC_CTX *_mem_save_next_0;
8704         if (ndr_flags & NDR_SCALARS) {
8705                 NDR_CHECK(ndr_pull_align(ndr, 5));
8706                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
8707                 if (_ptr_next) {
8708                         NDR_PULL_ALLOC(ndr, r->next);
8709                 } else {
8710                         r->next = NULL;
8711                 }
8712                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8713                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8714         }
8715         if (ndr_flags & NDR_BUFFERS) {
8716                 if (r->next) {
8717                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
8718                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
8719                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8720                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
8721                 }
8722                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8723         }
8724         return NDR_ERR_SUCCESS;
8725 }
8726
8727 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorListItem1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8728 {
8729         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorListItem1");
8730         ndr->depth++;
8731         ndr_print_ptr(ndr, "next", r->next);
8732         ndr->depth++;
8733         if (r->next) {
8734                 ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "next", r->next);
8735         }
8736         ndr->depth--;
8737         ndr_print_drsuapi_DsAddEntryExtraError1(ndr, "error", &r->error);
8738         ndr->depth--;
8739 }
8740
8741 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8742 {
8743         if (ndr_flags & NDR_SCALARS) {
8744                 NDR_CHECK(ndr_push_align(ndr, 5));
8745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8746                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8747                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8748                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8749         }
8750         if (ndr_flags & NDR_BUFFERS) {
8751                 if (r->id) {
8752                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8753                 }
8754                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8755         }
8756         return NDR_ERR_SUCCESS;
8757 }
8758
8759 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfo1 *r)
8760 {
8761         uint32_t _ptr_id;
8762         TALLOC_CTX *_mem_save_id_0;
8763         if (ndr_flags & NDR_SCALARS) {
8764                 NDR_CHECK(ndr_pull_align(ndr, 5));
8765                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8766                 if (_ptr_id) {
8767                         NDR_PULL_ALLOC(ndr, r->id);
8768                 } else {
8769                         r->id = NULL;
8770                 }
8771                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8772                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8773                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8774         }
8775         if (ndr_flags & NDR_BUFFERS) {
8776                 if (r->id) {
8777                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8778                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8779                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8780                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8781                 }
8782                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8783         }
8784         return NDR_ERR_SUCCESS;
8785 }
8786
8787 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8788 {
8789         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfo1");
8790         ndr->depth++;
8791         ndr_print_ptr(ndr, "id", r->id);
8792         ndr->depth++;
8793         if (r->id) {
8794                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8795         }
8796         ndr->depth--;
8797         ndr_print_WERROR(ndr, "status", r->status);
8798         ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "first", &r->first);
8799         ndr->depth--;
8800 }
8801
8802 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryErrorInfo *r)
8803 {
8804         if (ndr_flags & NDR_SCALARS) {
8805                 int level = ndr_push_get_switch_value(ndr, r);
8806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8807                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8808                 switch (level) {
8809                         case 1: {
8810                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8811                         break; }
8812
8813                         case 4: {
8814                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8815                         break; }
8816
8817                         case 5: {
8818                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8819                         break; }
8820
8821                         case 6: {
8822                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8823                         break; }
8824
8825                         case 7: {
8826                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8827                         break; }
8828
8829                         default:
8830                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8831                 }
8832         }
8833         if (ndr_flags & NDR_BUFFERS) {
8834                 int level = ndr_push_get_switch_value(ndr, r);
8835                 switch (level) {
8836                         case 1:
8837                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8838                         break;
8839
8840                         case 4:
8841                         break;
8842
8843                         case 5:
8844                         break;
8845
8846                         case 6:
8847                         break;
8848
8849                         case 7:
8850                         break;
8851
8852                         default:
8853                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8854                 }
8855         }
8856         return NDR_ERR_SUCCESS;
8857 }
8858
8859 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryErrorInfo *r)
8860 {
8861         int level;
8862         uint32_t _level;
8863         level = ndr_pull_get_switch_value(ndr, r);
8864         if (ndr_flags & NDR_SCALARS) {
8865                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8866                 if (_level != level) {
8867                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8868                 }
8869                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8870                 switch (level) {
8871                         case 1: {
8872                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8873                         break; }
8874
8875                         case 4: {
8876                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8877                         break; }
8878
8879                         case 5: {
8880                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8881                         break; }
8882
8883                         case 6: {
8884                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8885                         break; }
8886
8887                         case 7: {
8888                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8889                         break; }
8890
8891                         default:
8892                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8893                 }
8894         }
8895         if (ndr_flags & NDR_BUFFERS) {
8896                 switch (level) {
8897                         case 1:
8898                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8899                         break;
8900
8901                         case 4:
8902                         break;
8903
8904                         case 5:
8905                         break;
8906
8907                         case 6:
8908                         break;
8909
8910                         case 7:
8911                         break;
8912
8913                         default:
8914                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8915                 }
8916         }
8917         return NDR_ERR_SUCCESS;
8918 }
8919
8920 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryErrorInfo *r)
8921 {
8922         int level;
8923         level = ndr_print_get_switch_value(ndr, r);
8924         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryErrorInfo");
8925         switch (level) {
8926                 case 1:
8927                         ndr_print_drsuapi_DsAddEntryErrorInfo1(ndr, "error1", &r->error1);
8928                 break;
8929
8930                 case 4:
8931                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8932                 break;
8933
8934                 case 5:
8935                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8936                 break;
8937
8938                 case 6:
8939                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8940                 break;
8941
8942                 case 7:
8943                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8944                 break;
8945
8946                 default:
8947                         ndr_print_bad_level(ndr, name, level);
8948         }
8949 }
8950
8951 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryError1 *r)
8952 {
8953         if (ndr_flags & NDR_SCALARS) {
8954                 NDR_CHECK(ndr_push_align(ndr, 5));
8955                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8956                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8957                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
8958                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8959         }
8960         if (ndr_flags & NDR_BUFFERS) {
8961                 if (r->info) {
8962                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->info, r->level));
8963                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8964                 }
8965         }
8966         return NDR_ERR_SUCCESS;
8967 }
8968
8969 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryError1 *r)
8970 {
8971         uint32_t _ptr_info;
8972         TALLOC_CTX *_mem_save_info_0;
8973         if (ndr_flags & NDR_SCALARS) {
8974                 NDR_CHECK(ndr_pull_align(ndr, 5));
8975                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8976                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8977                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8978                 if (_ptr_info) {
8979                         NDR_PULL_ALLOC(ndr, r->info);
8980                 } else {
8981                         r->info = NULL;
8982                 }
8983                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8984         }
8985         if (ndr_flags & NDR_BUFFERS) {
8986                 if (r->info) {
8987                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8988                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
8989                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->info, r->level));
8990                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8991                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8992                 }
8993         }
8994         return NDR_ERR_SUCCESS;
8995 }
8996
8997 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryError1 *r)
8998 {
8999         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryError1");
9000         ndr->depth++;
9001         ndr_print_WERROR(ndr, "status", r->status);
9002         ndr_print_uint32(ndr, "level", r->level);
9003         ndr_print_ptr(ndr, "info", r->info);
9004         ndr->depth++;
9005         if (r->info) {
9006                 ndr_print_set_switch_value(ndr, r->info, r->level);
9007                 ndr_print_drsuapi_DsAddEntryErrorInfo(ndr, "info", r->info);
9008         }
9009         ndr->depth--;
9010         ndr->depth--;
9011 }
9012
9013 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryError *r)
9014 {
9015         if (ndr_flags & NDR_SCALARS) {
9016                 int level = ndr_push_get_switch_value(ndr, r);
9017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9018                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9019                 switch (level) {
9020                         case 1: {
9021                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
9022                         break; }
9023
9024                         default:
9025                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9026                 }
9027         }
9028         if (ndr_flags & NDR_BUFFERS) {
9029                 int level = ndr_push_get_switch_value(ndr, r);
9030                 switch (level) {
9031                         case 1:
9032                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
9033                         break;
9034
9035                         default:
9036                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9037                 }
9038         }
9039         return NDR_ERR_SUCCESS;
9040 }
9041
9042 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryError *r)
9043 {
9044         int level;
9045         uint32_t _level;
9046         level = ndr_pull_get_switch_value(ndr, r);
9047         if (ndr_flags & NDR_SCALARS) {
9048                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9049                 if (_level != level) {
9050                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9051                 }
9052                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9053                 switch (level) {
9054                         case 1: {
9055                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
9056                         break; }
9057
9058                         default:
9059                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9060                 }
9061         }
9062         if (ndr_flags & NDR_BUFFERS) {
9063                 switch (level) {
9064                         case 1:
9065                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
9066                         break;
9067
9068                         default:
9069                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9070                 }
9071         }
9072         return NDR_ERR_SUCCESS;
9073 }
9074
9075 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryError *r)
9076 {
9077         int level;
9078         level = ndr_print_get_switch_value(ndr, r);
9079         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryError");
9080         switch (level) {
9081                 case 1:
9082                         ndr_print_drsuapi_DsAddEntryError1(ndr, "info1", &r->info1);
9083                 break;
9084
9085                 default:
9086                         ndr_print_bad_level(ndr, name, level);
9087         }
9088 }
9089
9090 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9091 {
9092         if (ndr_flags & NDR_SCALARS) {
9093                 NDR_CHECK(ndr_push_align(ndr, 4));
9094                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
9095                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9096                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9097         }
9098         if (ndr_flags & NDR_BUFFERS) {
9099                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9100         }
9101         return NDR_ERR_SUCCESS;
9102 }
9103
9104 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier2 *r)
9105 {
9106         if (ndr_flags & NDR_SCALARS) {
9107                 NDR_CHECK(ndr_pull_align(ndr, 4));
9108                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
9109                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9110                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9111         }
9112         if (ndr_flags & NDR_BUFFERS) {
9113                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9114         }
9115         return NDR_ERR_SUCCESS;
9116 }
9117
9118 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9119 {
9120         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier2");
9121         ndr->depth++;
9122         ndr_print_GUID(ndr, "guid", &r->guid);
9123         ndr_print_dom_sid28(ndr, "sid", &r->sid);
9124         ndr->depth--;
9125 }
9126
9127 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr2 *r)
9128 {
9129         uint32_t cntr_objects_1;
9130         if (ndr_flags & NDR_SCALARS) {
9131                 NDR_CHECK(ndr_push_align(ndr, 5));
9132                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9133                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9134                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9135                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9136                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9137                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9138         }
9139         if (ndr_flags & NDR_BUFFERS) {
9140                 if (r->id) {
9141                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9142                 }
9143                 if (r->objects) {
9144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9145                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9146                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9147                         }
9148                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9149                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9150                         }
9151                 }
9152         }
9153         return NDR_ERR_SUCCESS;
9154 }
9155
9156 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr2 *r)
9157 {
9158         uint32_t _ptr_id;
9159         TALLOC_CTX *_mem_save_id_0;
9160         uint32_t _ptr_objects;
9161         uint32_t cntr_objects_1;
9162         TALLOC_CTX *_mem_save_objects_0;
9163         TALLOC_CTX *_mem_save_objects_1;
9164         if (ndr_flags & NDR_SCALARS) {
9165                 NDR_CHECK(ndr_pull_align(ndr, 5));
9166                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9167                 if (_ptr_id) {
9168                         NDR_PULL_ALLOC(ndr, r->id);
9169                 } else {
9170                         r->id = NULL;
9171                 }
9172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9173                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9174                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9175                 if (r->count > 10000) {
9176                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9177                 }
9178                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9179                 if (_ptr_objects) {
9180                         NDR_PULL_ALLOC(ndr, r->objects);
9181                 } else {
9182                         r->objects = NULL;
9183                 }
9184                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9185         }
9186         if (ndr_flags & NDR_BUFFERS) {
9187                 if (r->id) {
9188                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9189                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9190                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9192                 }
9193                 if (r->objects) {
9194                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9195                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9197                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9198                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9199                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9200                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9201                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9202                         }
9203                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9204                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9205                         }
9206                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9207                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9208                 }
9209                 if (r->objects) {
9210                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9211                 }
9212         }
9213         return NDR_ERR_SUCCESS;
9214 }
9215
9216 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr2 *r)
9217 {
9218         uint32_t cntr_objects_1;
9219         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr2");
9220         ndr->depth++;
9221         ndr_print_ptr(ndr, "id", r->id);
9222         ndr->depth++;
9223         if (r->id) {
9224                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9225         }
9226         ndr->depth--;
9227         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9228         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
9229         ndr_print_uint32(ndr, "count", r->count);
9230         ndr_print_ptr(ndr, "objects", r->objects);
9231         ndr->depth++;
9232         if (r->objects) {
9233                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9234                 ndr->depth++;
9235                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9236                         char *idx_1=NULL;
9237                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9238                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9239                                 free(idx_1);
9240                         }
9241                 }
9242                 ndr->depth--;
9243         }
9244         ndr->depth--;
9245         ndr->depth--;
9246 }
9247
9248 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr3 *r)
9249 {
9250         uint32_t cntr_objects_1;
9251         if (ndr_flags & NDR_SCALARS) {
9252                 NDR_CHECK(ndr_push_align(ndr, 5));
9253                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9255                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
9256                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9257                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9258                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9259         }
9260         if (ndr_flags & NDR_BUFFERS) {
9261                 if (r->id) {
9262                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9263                 }
9264                 if (r->error) {
9265                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->error, r->level));
9266                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9267                 }
9268                 if (r->objects) {
9269                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9270                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9271                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9272                         }
9273                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9274                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9275                         }
9276                 }
9277         }
9278         return NDR_ERR_SUCCESS;
9279 }
9280
9281 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr3 *r)
9282 {
9283         uint32_t _ptr_id;
9284         TALLOC_CTX *_mem_save_id_0;
9285         uint32_t _ptr_error;
9286         TALLOC_CTX *_mem_save_error_0;
9287         uint32_t _ptr_objects;
9288         uint32_t cntr_objects_1;
9289         TALLOC_CTX *_mem_save_objects_0;
9290         TALLOC_CTX *_mem_save_objects_1;
9291         if (ndr_flags & NDR_SCALARS) {
9292                 NDR_CHECK(ndr_pull_align(ndr, 5));
9293                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9294                 if (_ptr_id) {
9295                         NDR_PULL_ALLOC(ndr, r->id);
9296                 } else {
9297                         r->id = NULL;
9298                 }
9299                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9300                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_error));
9301                 if (_ptr_error) {
9302                         NDR_PULL_ALLOC(ndr, r->error);
9303                 } else {
9304                         r->error = NULL;
9305                 }
9306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9307                 if (r->count > 10000) {
9308                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9309                 }
9310                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9311                 if (_ptr_objects) {
9312                         NDR_PULL_ALLOC(ndr, r->objects);
9313                 } else {
9314                         r->objects = NULL;
9315                 }
9316                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9317         }
9318         if (ndr_flags & NDR_BUFFERS) {
9319                 if (r->id) {
9320                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9321                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9322                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9323                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9324                 }
9325                 if (r->error) {
9326                         _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
9327                         NDR_PULL_SET_MEM_CTX(ndr, r->error, 0);
9328                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->error, r->level));
9329                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9330                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, 0);
9331                 }
9332                 if (r->objects) {
9333                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9334                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9335                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9336                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9337                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9338                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9339                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9340                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9341                         }
9342                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9343                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9344                         }
9345                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9346                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9347                 }
9348                 if (r->objects) {
9349                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9350                 }
9351         }
9352         return NDR_ERR_SUCCESS;
9353 }
9354
9355 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr3 *r)
9356 {
9357         uint32_t cntr_objects_1;
9358         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr3");
9359         ndr->depth++;
9360         ndr_print_ptr(ndr, "id", r->id);
9361         ndr->depth++;
9362         if (r->id) {
9363                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9364         }
9365         ndr->depth--;
9366         ndr_print_uint32(ndr, "level", r->level);
9367         ndr_print_ptr(ndr, "error", r->error);
9368         ndr->depth++;
9369         if (r->error) {
9370                 ndr_print_set_switch_value(ndr, r->error, r->level);
9371                 ndr_print_drsuapi_DsAddEntryError(ndr, "error", r->error);
9372         }
9373         ndr->depth--;
9374         ndr_print_uint32(ndr, "count", r->count);
9375         ndr_print_ptr(ndr, "objects", r->objects);
9376         ndr->depth++;
9377         if (r->objects) {
9378                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9379                 ndr->depth++;
9380                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9381                         char *idx_1=NULL;
9382                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9383                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9384                                 free(idx_1);
9385                         }
9386                 }
9387                 ndr->depth--;
9388         }
9389         ndr->depth--;
9390         ndr->depth--;
9391 }
9392
9393 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryCtr *r)
9394 {
9395         if (ndr_flags & NDR_SCALARS) {
9396                 int level = ndr_push_get_switch_value(ndr, r);
9397                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
9398                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9399                 switch (level) {
9400                         case 2: {
9401                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9402                         break; }
9403
9404                         case 3: {
9405                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9406                         break; }
9407
9408                         default:
9409                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9410                 }
9411         }
9412         if (ndr_flags & NDR_BUFFERS) {
9413                 int level = ndr_push_get_switch_value(ndr, r);
9414                 switch (level) {
9415                         case 2:
9416                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9417                         break;
9418
9419                         case 3:
9420                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9421                         break;
9422
9423                         default:
9424                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9425                 }
9426         }
9427         return NDR_ERR_SUCCESS;
9428 }
9429
9430 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryCtr *r)
9431 {
9432         int level;
9433         int32_t _level;
9434         level = ndr_pull_get_switch_value(ndr, r);
9435         if (ndr_flags & NDR_SCALARS) {
9436                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
9437                 if (_level != level) {
9438                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9439                 }
9440                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9441                 switch (level) {
9442                         case 2: {
9443                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9444                         break; }
9445
9446                         case 3: {
9447                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9448                         break; }
9449
9450                         default:
9451                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9452                 }
9453         }
9454         if (ndr_flags & NDR_BUFFERS) {
9455                 switch (level) {
9456                         case 2:
9457                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9458                         break;
9459
9460                         case 3:
9461                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9462                         break;
9463
9464                         default:
9465                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9466                 }
9467         }
9468         return NDR_ERR_SUCCESS;
9469 }
9470
9471 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
9472 {
9473         int level;
9474         level = ndr_print_get_switch_value(ndr, r);
9475         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
9476         switch (level) {
9477                 case 2:
9478                         ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
9479                 break;
9480
9481                 case 3:
9482                         ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
9483                 break;
9484
9485                 default:
9486                         ndr_print_bad_level(ndr, name, level);
9487         }
9488 }
9489
9490 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9491 {
9492         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9493         return NDR_ERR_SUCCESS;
9494 }
9495
9496 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9497 {
9498         uint32_t v;
9499         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9500         *r = v;
9501         return NDR_ERR_SUCCESS;
9502 }
9503
9504 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCFlags(struct ndr_print *ndr, const char *name, uint32_t r)
9505 {
9506         ndr_print_uint32(ndr, name, r);
9507         ndr->depth++;
9508         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION, r);
9509         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_DAMPED", DRSUAPI_DS_EXECUTE_KCC_DAMPED, r);
9510         ndr->depth--;
9511 }
9512
9513 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsExecuteKCC1 *r)
9514 {
9515         if (ndr_flags & NDR_SCALARS) {
9516                 NDR_CHECK(ndr_push_align(ndr, 4));
9517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->taskID));
9518                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, r->flags));
9519                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9520         }
9521         if (ndr_flags & NDR_BUFFERS) {
9522         }
9523         return NDR_ERR_SUCCESS;
9524 }
9525
9526 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsExecuteKCC1 *r)
9527 {
9528         if (ndr_flags & NDR_SCALARS) {
9529                 NDR_CHECK(ndr_pull_align(ndr, 4));
9530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->taskID));
9531                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, &r->flags));
9532                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9533         }
9534         if (ndr_flags & NDR_BUFFERS) {
9535         }
9536         return NDR_ERR_SUCCESS;
9537 }
9538
9539 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsExecuteKCC1 *r)
9540 {
9541         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC1");
9542         ndr->depth++;
9543         ndr_print_uint32(ndr, "taskID", r->taskID);
9544         ndr_print_drsuapi_DsExecuteKCCFlags(ndr, "flags", r->flags);
9545         ndr->depth--;
9546 }
9547
9548 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsExecuteKCCRequest *r)
9549 {
9550         if (ndr_flags & NDR_SCALARS) {
9551                 int level = ndr_push_get_switch_value(ndr, r);
9552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9553                 NDR_CHECK(ndr_push_union_align(ndr, 4));
9554                 switch (level) {
9555                         case 1: {
9556                                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9557                         break; }
9558
9559                         default:
9560                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9561                 }
9562         }
9563         if (ndr_flags & NDR_BUFFERS) {
9564                 int level = ndr_push_get_switch_value(ndr, r);
9565                 switch (level) {
9566                         case 1:
9567                         break;
9568
9569                         default:
9570                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9571                 }
9572         }
9573         return NDR_ERR_SUCCESS;
9574 }
9575
9576 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsExecuteKCCRequest *r)
9577 {
9578         int level;
9579         uint32_t _level;
9580         level = ndr_pull_get_switch_value(ndr, r);
9581         if (ndr_flags & NDR_SCALARS) {
9582                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9583                 if (_level != level) {
9584                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9585                 }
9586                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
9587                 switch (level) {
9588                         case 1: {
9589                                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9590                         break; }
9591
9592                         default:
9593                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9594                 }
9595         }
9596         if (ndr_flags & NDR_BUFFERS) {
9597                 switch (level) {
9598                         case 1:
9599                         break;
9600
9601                         default:
9602                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9603                 }
9604         }
9605         return NDR_ERR_SUCCESS;
9606 }
9607
9608 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsExecuteKCCRequest *r)
9609 {
9610         int level;
9611         level = ndr_print_get_switch_value(ndr, r);
9612         ndr_print_union(ndr, name, level, "drsuapi_DsExecuteKCCRequest");
9613         switch (level) {
9614                 case 1:
9615                         ndr_print_drsuapi_DsExecuteKCC1(ndr, "ctr1", &r->ctr1);
9616                 break;
9617
9618                 default:
9619                         ndr_print_bad_level(ndr, name, level);
9620         }
9621 }
9622
9623 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
9624 {
9625         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9626         return NDR_ERR_SUCCESS;
9627 }
9628
9629 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
9630 {
9631         uint32_t v;
9632         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9633         *r = v;
9634         return NDR_ERR_SUCCESS;
9635 }
9636
9637 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaGetInfoLevel r)
9638 {
9639         const char *val = NULL;
9640
9641         switch (r) {
9642                 case DRSUAPI_DS_REPLICA_GET_INFO: val = "DRSUAPI_DS_REPLICA_GET_INFO"; break;
9643                 case DRSUAPI_DS_REPLICA_GET_INFO2: val = "DRSUAPI_DS_REPLICA_GET_INFO2"; break;
9644         }
9645         ndr_print_enum(ndr, name, "ENUM", val, r);
9646 }
9647
9648 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
9649 {
9650         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9651         return NDR_ERR_SUCCESS;
9652 }
9653
9654 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
9655 {
9656         uint32_t v;
9657         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9658         *r = v;
9659         return NDR_ERR_SUCCESS;
9660 }
9661
9662 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaInfoType r)
9663 {
9664         const char *val = NULL;
9665
9666         switch (r) {
9667                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS"; break;
9668                 case DRSUAPI_DS_REPLICA_INFO_CURSORS: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS"; break;
9669                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA"; break;
9670                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES"; break;
9671                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES"; break;
9672                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: val = "DRSUAPI_DS_REPLICA_INFO_PENDING_OPS"; break;
9673                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA"; break;
9674                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS2"; break;
9675                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS3"; break;
9676                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2"; break;
9677                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2"; break;
9678                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02"; break;
9679                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: val = "DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04"; break;
9680                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS05"; break;
9681                 case DRSUAPI_DS_REPLICA_INFO_06: val = "DRSUAPI_DS_REPLICA_INFO_06"; break;
9682         }
9683         ndr_print_enum(ndr, name, "ENUM", val, r);
9684 }
9685
9686 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9687 {
9688         if (ndr_flags & NDR_SCALARS) {
9689                 NDR_CHECK(ndr_push_align(ndr, 5));
9690                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9691                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9692                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9693                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9694         }
9695         if (ndr_flags & NDR_BUFFERS) {
9696                 if (r->object_dn) {
9697                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9698                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9699                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9700                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9701                 }
9702         }
9703         return NDR_ERR_SUCCESS;
9704 }
9705
9706 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
9707 {
9708         uint32_t _ptr_object_dn;
9709         TALLOC_CTX *_mem_save_object_dn_0;
9710         if (ndr_flags & NDR_SCALARS) {
9711                 NDR_CHECK(ndr_pull_align(ndr, 5));
9712                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9713                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9714                 if (_ptr_object_dn) {
9715                         NDR_PULL_ALLOC(ndr, r->object_dn);
9716                 } else {
9717                         r->object_dn = NULL;
9718                 }
9719                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9720                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9721         }
9722         if (ndr_flags & NDR_BUFFERS) {
9723                 if (r->object_dn) {
9724                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9725                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9726                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9727                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9728                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9729                                 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));
9730                         }
9731                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9732                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9733                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9734                 }
9735         }
9736         return NDR_ERR_SUCCESS;
9737 }
9738
9739 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9740 {
9741         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest1");
9742         ndr->depth++;
9743         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9744         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9745         ndr->depth++;
9746         if (r->object_dn) {
9747                 ndr_print_string(ndr, "object_dn", r->object_dn);
9748         }
9749         ndr->depth--;
9750         ndr_print_GUID(ndr, "guid1", &r->guid1);
9751         ndr->depth--;
9752 }
9753
9754 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9755 {
9756         if (ndr_flags & NDR_SCALARS) {
9757                 NDR_CHECK(ndr_push_align(ndr, 5));
9758                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9759                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9760                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9762                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string1));
9763                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string2));
9764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
9765                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9766         }
9767         if (ndr_flags & NDR_BUFFERS) {
9768                 if (r->object_dn) {
9769                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9770                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9771                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9772                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9773                 }
9774                 if (r->string1) {
9775                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9776                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9777                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9778                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string1, ndr_charset_length(r->string1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9779                 }
9780                 if (r->string2) {
9781                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9782                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9783                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9784                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string2, ndr_charset_length(r->string2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9785                 }
9786         }
9787         return NDR_ERR_SUCCESS;
9788 }
9789
9790 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
9791 {
9792         uint32_t _ptr_object_dn;
9793         TALLOC_CTX *_mem_save_object_dn_0;
9794         uint32_t _ptr_string1;
9795         TALLOC_CTX *_mem_save_string1_0;
9796         uint32_t _ptr_string2;
9797         TALLOC_CTX *_mem_save_string2_0;
9798         if (ndr_flags & NDR_SCALARS) {
9799                 NDR_CHECK(ndr_pull_align(ndr, 5));
9800                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9801                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9802                 if (_ptr_object_dn) {
9803                         NDR_PULL_ALLOC(ndr, r->object_dn);
9804                 } else {
9805                         r->object_dn = NULL;
9806                 }
9807                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9809                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string1));
9810                 if (_ptr_string1) {
9811                         NDR_PULL_ALLOC(ndr, r->string1);
9812                 } else {
9813                         r->string1 = NULL;
9814                 }
9815                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string2));
9816                 if (_ptr_string2) {
9817                         NDR_PULL_ALLOC(ndr, r->string2);
9818                 } else {
9819                         r->string2 = NULL;
9820                 }
9821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
9822                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9823         }
9824         if (ndr_flags & NDR_BUFFERS) {
9825                 if (r->object_dn) {
9826                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9827                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9828                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9829                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9830                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9831                                 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));
9832                         }
9833                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9834                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9836                 }
9837                 if (r->string1) {
9838                         _mem_save_string1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9839                         NDR_PULL_SET_MEM_CTX(ndr, r->string1, 0);
9840                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string1));
9841                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string1));
9842                         if (ndr_get_array_length(ndr, &r->string1) > ndr_get_array_size(ndr, &r->string1)) {
9843                                 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));
9844                         }
9845                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t)));
9846                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string1, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t), CH_UTF16));
9847                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string1_0, 0);
9848                 }
9849                 if (r->string2) {
9850                         _mem_save_string2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9851                         NDR_PULL_SET_MEM_CTX(ndr, r->string2, 0);
9852                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string2));
9853                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string2));
9854                         if (ndr_get_array_length(ndr, &r->string2) > ndr_get_array_size(ndr, &r->string2)) {
9855                                 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));
9856                         }
9857                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t)));
9858                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string2, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t), CH_UTF16));
9859                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string2_0, 0);
9860                 }
9861         }
9862         return NDR_ERR_SUCCESS;
9863 }
9864
9865 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9866 {
9867         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest2");
9868         ndr->depth++;
9869         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9870         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9871         ndr->depth++;
9872         if (r->object_dn) {
9873                 ndr_print_string(ndr, "object_dn", r->object_dn);
9874         }
9875         ndr->depth--;
9876         ndr_print_GUID(ndr, "guid1", &r->guid1);
9877         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9878         ndr_print_ptr(ndr, "string1", r->string1);
9879         ndr->depth++;
9880         if (r->string1) {
9881                 ndr_print_string(ndr, "string1", r->string1);
9882         }
9883         ndr->depth--;
9884         ndr_print_ptr(ndr, "string2", r->string2);
9885         ndr->depth++;
9886         if (r->string2) {
9887                 ndr_print_string(ndr, "string2", r->string2);
9888         }
9889         ndr->depth--;
9890         ndr_print_uint32(ndr, "unknown2", r->unknown2);
9891         ndr->depth--;
9892 }
9893
9894 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaGetInfoRequest *r)
9895 {
9896         if (ndr_flags & NDR_SCALARS) {
9897                 int level = ndr_push_get_switch_value(ndr, r);
9898                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
9899                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9900                 switch (level) {
9901                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9902                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9903                         break; }
9904
9905                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9906                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9907                         break; }
9908
9909                         default:
9910                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9911                 }
9912         }
9913         if (ndr_flags & NDR_BUFFERS) {
9914                 int level = ndr_push_get_switch_value(ndr, r);
9915                 switch (level) {
9916                         case DRSUAPI_DS_REPLICA_GET_INFO:
9917                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9918                         break;
9919
9920                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9921                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9922                         break;
9923
9924                         default:
9925                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9926                 }
9927         }
9928         return NDR_ERR_SUCCESS;
9929 }
9930
9931 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaGetInfoRequest *r)
9932 {
9933         int level;
9934         uint32_t _level;
9935         level = ndr_pull_get_switch_value(ndr, r);
9936         if (ndr_flags & NDR_SCALARS) {
9937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9938                 if (_level != level) {
9939                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9940                 }
9941                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9942                 switch (level) {
9943                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9944                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9945                         break; }
9946
9947                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9948                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9949                         break; }
9950
9951                         default:
9952                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9953                 }
9954         }
9955         if (ndr_flags & NDR_BUFFERS) {
9956                 switch (level) {
9957                         case DRSUAPI_DS_REPLICA_GET_INFO:
9958                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9959                         break;
9960
9961                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9962                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9963                         break;
9964
9965                         default:
9966                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9967                 }
9968         }
9969         return NDR_ERR_SUCCESS;
9970 }
9971
9972 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaGetInfoRequest *r)
9973 {
9974         int level;
9975         level = ndr_print_get_switch_value(ndr, r);
9976         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaGetInfoRequest");
9977         switch (level) {
9978                 case DRSUAPI_DS_REPLICA_GET_INFO:
9979                         ndr_print_drsuapi_DsReplicaGetInfoRequest1(ndr, "req1", &r->req1);
9980                 break;
9981
9982                 case DRSUAPI_DS_REPLICA_GET_INFO2:
9983                         ndr_print_drsuapi_DsReplicaGetInfoRequest2(ndr, "req2", &r->req2);
9984                 break;
9985
9986                 default:
9987                         ndr_print_bad_level(ndr, name, level);
9988         }
9989 }
9990
9991 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbour *r)
9992 {
9993         if (ndr_flags & NDR_SCALARS) {
9994                 NDR_CHECK(ndr_push_align(ndr, 8));
9995                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context_dn));
9996                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
9997                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
9998                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_obj_dn));
9999                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
10000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10001                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
10002                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
10003                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
10004                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
10005                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
10006                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
10007                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_success));
10008                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
10009                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
10010                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
10011                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10012         }
10013         if (ndr_flags & NDR_BUFFERS) {
10014                 if (r->naming_context_dn) {
10015                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
10016                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10017                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
10018                         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));
10019                 }
10020                 if (r->source_dsa_obj_dn) {
10021                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
10022                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10023                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
10024                         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));
10025                 }
10026                 if (r->source_dsa_address) {
10027                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
10028                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10029                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
10030                         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));
10031                 }
10032                 if (r->transport_obj_dn) {
10033                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
10034                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10035                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
10036                         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));
10037                 }
10038         }
10039         return NDR_ERR_SUCCESS;
10040 }
10041
10042 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
10043 {
10044         uint32_t _ptr_naming_context_dn;
10045         TALLOC_CTX *_mem_save_naming_context_dn_0;
10046         uint32_t _ptr_source_dsa_obj_dn;
10047         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
10048         uint32_t _ptr_source_dsa_address;
10049         TALLOC_CTX *_mem_save_source_dsa_address_0;
10050         uint32_t _ptr_transport_obj_dn;
10051         TALLOC_CTX *_mem_save_transport_obj_dn_0;
10052         if (ndr_flags & NDR_SCALARS) {
10053                 NDR_CHECK(ndr_pull_align(ndr, 8));
10054                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context_dn));
10055                 if (_ptr_naming_context_dn) {
10056                         NDR_PULL_ALLOC(ndr, r->naming_context_dn);
10057                 } else {
10058                         r->naming_context_dn = NULL;
10059                 }
10060                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
10061                 if (_ptr_source_dsa_obj_dn) {
10062                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
10063                 } else {
10064                         r->source_dsa_obj_dn = NULL;
10065                 }
10066                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
10067                 if (_ptr_source_dsa_address) {
10068                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
10069                 } else {
10070                         r->source_dsa_address = NULL;
10071                 }
10072                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_obj_dn));
10073                 if (_ptr_transport_obj_dn) {
10074                         NDR_PULL_ALLOC(ndr, r->transport_obj_dn);
10075                 } else {
10076                         r->transport_obj_dn = NULL;
10077                 }
10078                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
10079                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10080                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
10081                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
10082                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
10083                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
10084                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
10085                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
10086                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_success));
10087                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
10088                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
10089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
10090                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10091         }
10092         if (ndr_flags & NDR_BUFFERS) {
10093                 if (r->naming_context_dn) {
10094                         _mem_save_naming_context_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10095                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
10096                         NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
10097                         NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
10098                         if (ndr_get_array_length(ndr, &r->naming_context_dn) > ndr_get_array_size(ndr, &r->naming_context_dn)) {
10099                                 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));
10100                         }
10101                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t)));
10102                         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));
10103                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
10104                 }
10105                 if (r->source_dsa_obj_dn) {
10106                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10107                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
10108                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
10109                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
10110                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
10111                                 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));
10112                         }
10113                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
10114                         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));
10115                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
10116                 }
10117                 if (r->source_dsa_address) {
10118                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10119                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
10120                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
10121                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
10122                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
10123                                 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));
10124                         }
10125                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
10126                         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));
10127                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
10128                 }
10129                 if (r->transport_obj_dn) {
10130                         _mem_save_transport_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10131                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
10132                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
10133                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
10134                         if (ndr_get_array_length(ndr, &r->transport_obj_dn) > ndr_get_array_size(ndr, &r->transport_obj_dn)) {
10135                                 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));
10136                         }
10137                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t)));
10138                         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));
10139                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
10140                 }
10141         }
10142         return NDR_ERR_SUCCESS;
10143 }
10144
10145 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbour(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbour *r)
10146 {
10147         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbour");
10148         ndr->depth++;
10149         ndr_print_ptr(ndr, "naming_context_dn", r->naming_context_dn);
10150         ndr->depth++;
10151         if (r->naming_context_dn) {
10152                 ndr_print_string(ndr, "naming_context_dn", r->naming_context_dn);
10153         }
10154         ndr->depth--;
10155         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10156         ndr->depth++;
10157         if (r->source_dsa_obj_dn) {
10158                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10159         }
10160         ndr->depth--;
10161         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
10162         ndr->depth++;
10163         if (r->source_dsa_address) {
10164                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
10165         }
10166         ndr->depth--;
10167         ndr_print_ptr(ndr, "transport_obj_dn", r->transport_obj_dn);
10168         ndr->depth++;
10169         if (r->transport_obj_dn) {
10170                 ndr_print_string(ndr, "transport_obj_dn", r->transport_obj_dn);
10171         }
10172         ndr->depth--;
10173         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
10174         ndr_print_uint32(ndr, "reserved", r->reserved);
10175         ndr_print_GUID(ndr, "naming_context_obj_guid", &r->naming_context_obj_guid);
10176         ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
10177         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
10178         ndr_print_GUID(ndr, "transport_obj_guid", &r->transport_obj_guid);
10179         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
10180         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
10181         ndr_print_NTTIME(ndr, "last_success", r->last_success);
10182         ndr_print_NTTIME(ndr, "last_attempt", r->last_attempt);
10183         ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
10184         ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
10185         ndr->depth--;
10186 }
10187
10188 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbourCtr *r)
10189 {
10190         uint32_t cntr_array_0;
10191         if (ndr_flags & NDR_SCALARS) {
10192                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10193                 NDR_CHECK(ndr_push_align(ndr, 8));
10194                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10195                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10196                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10197                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10198                 }
10199                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10200         }
10201         if (ndr_flags & NDR_BUFFERS) {
10202                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10203                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10204                 }
10205         }
10206         return NDR_ERR_SUCCESS;
10207 }
10208
10209 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
10210 {
10211         uint32_t cntr_array_0;
10212         TALLOC_CTX *_mem_save_array_0;
10213         if (ndr_flags & NDR_SCALARS) {
10214                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10215                 NDR_CHECK(ndr_pull_align(ndr, 8));
10216                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10217                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10218                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10219                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10220                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10221                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10222                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10223                 }
10224                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10225                 if (r->array) {
10226                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10227                 }
10228                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10229         }
10230         if (ndr_flags & NDR_BUFFERS) {
10231                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10232                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10233                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10234                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10235                 }
10236                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10237         }
10238         return NDR_ERR_SUCCESS;
10239 }
10240
10241 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbourCtr *r)
10242 {
10243         uint32_t cntr_array_0;
10244         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbourCtr");
10245         ndr->depth++;
10246         ndr_print_uint32(ndr, "count", r->count);
10247         ndr_print_uint32(ndr, "reserved", r->reserved);
10248         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10249         ndr->depth++;
10250         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10251                 char *idx_0=NULL;
10252                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10253                         ndr_print_drsuapi_DsReplicaNeighbour(ndr, "array", &r->array[cntr_array_0]);
10254                         free(idx_0);
10255                 }
10256         }
10257         ndr->depth--;
10258         ndr->depth--;
10259 }
10260
10261 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtr *r)
10262 {
10263         uint32_t cntr_array_0;
10264         if (ndr_flags & NDR_SCALARS) {
10265                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10266                 NDR_CHECK(ndr_push_align(ndr, 8));
10267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10269                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10270                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10271                 }
10272                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10273         }
10274         if (ndr_flags & NDR_BUFFERS) {
10275         }
10276         return NDR_ERR_SUCCESS;
10277 }
10278
10279 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
10280 {
10281         uint32_t cntr_array_0;
10282         TALLOC_CTX *_mem_save_array_0;
10283         if (ndr_flags & NDR_SCALARS) {
10284                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10285                 NDR_CHECK(ndr_pull_align(ndr, 8));
10286                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10287                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10288                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10289                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10290                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10291                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10292                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10293                 }
10294                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10295                 if (r->array) {
10296                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10297                 }
10298                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10299         }
10300         if (ndr_flags & NDR_BUFFERS) {
10301         }
10302         return NDR_ERR_SUCCESS;
10303 }
10304
10305 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtr *r)
10306 {
10307         uint32_t cntr_array_0;
10308         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtr");
10309         ndr->depth++;
10310         ndr_print_uint32(ndr, "count", r->count);
10311         ndr_print_uint32(ndr, "reserved", r->reserved);
10312         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10313         ndr->depth++;
10314         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10315                 char *idx_0=NULL;
10316                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10317                         ndr_print_drsuapi_DsReplicaCursor(ndr, "array", &r->array[cntr_array_0]);
10318                         free(idx_0);
10319                 }
10320         }
10321         ndr->depth--;
10322         ndr->depth--;
10323 }
10324
10325 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData *r)
10326 {
10327         if (ndr_flags & NDR_SCALARS) {
10328                 NDR_CHECK(ndr_push_align(ndr, 8));
10329                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10331                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10332                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10333                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10334                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10335                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10336         }
10337         if (ndr_flags & NDR_BUFFERS) {
10338                 if (r->attribute_name) {
10339                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10340                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10341                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10342                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10343                 }
10344         }
10345         return NDR_ERR_SUCCESS;
10346 }
10347
10348 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
10349 {
10350         uint32_t _ptr_attribute_name;
10351         TALLOC_CTX *_mem_save_attribute_name_0;
10352         if (ndr_flags & NDR_SCALARS) {
10353                 NDR_CHECK(ndr_pull_align(ndr, 8));
10354                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10355                 if (_ptr_attribute_name) {
10356                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10357                 } else {
10358                         r->attribute_name = NULL;
10359                 }
10360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10361                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10362                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10363                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10364                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10365                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10366         }
10367         if (ndr_flags & NDR_BUFFERS) {
10368                 if (r->attribute_name) {
10369                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10370                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10371                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10372                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10373                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10374                                 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));
10375                         }
10376                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10377                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10378                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10379                 }
10380         }
10381         return NDR_ERR_SUCCESS;
10382 }
10383
10384 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData *r)
10385 {
10386         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData");
10387         ndr->depth++;
10388         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10389         ndr->depth++;
10390         if (r->attribute_name) {
10391                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10392         }
10393         ndr->depth--;
10394         ndr_print_uint32(ndr, "version", r->version);
10395         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10396         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10397         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10398         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10399         ndr->depth--;
10400 }
10401
10402 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10403 {
10404         uint32_t cntr_array_0;
10405         if (ndr_flags & NDR_SCALARS) {
10406                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10407                 NDR_CHECK(ndr_push_align(ndr, 8));
10408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10409                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10410                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10411                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10412                 }
10413                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10414         }
10415         if (ndr_flags & NDR_BUFFERS) {
10416                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10417                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10418                 }
10419         }
10420         return NDR_ERR_SUCCESS;
10421 }
10422
10423 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
10424 {
10425         uint32_t cntr_array_0;
10426         TALLOC_CTX *_mem_save_array_0;
10427         if (ndr_flags & NDR_SCALARS) {
10428                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10429                 NDR_CHECK(ndr_pull_align(ndr, 8));
10430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10432                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10433                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10434                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10435                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10436                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10437                 }
10438                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10439                 if (r->array) {
10440                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10441                 }
10442                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10443         }
10444         if (ndr_flags & NDR_BUFFERS) {
10445                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10446                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10447                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10448                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10449                 }
10450                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10451         }
10452         return NDR_ERR_SUCCESS;
10453 }
10454
10455 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10456 {
10457         uint32_t cntr_array_0;
10458         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaDataCtr");
10459         ndr->depth++;
10460         ndr_print_uint32(ndr, "count", r->count);
10461         ndr_print_uint32(ndr, "reserved", r->reserved);
10462         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10463         ndr->depth++;
10464         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10465                 char *idx_0=NULL;
10466                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10467                         ndr_print_drsuapi_DsReplicaObjMetaData(ndr, "array", &r->array[cntr_array_0]);
10468                         free(idx_0);
10469                 }
10470         }
10471         ndr->depth--;
10472         ndr->depth--;
10473 }
10474
10475 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
10476 {
10477         if (ndr_flags & NDR_SCALARS) {
10478                 NDR_CHECK(ndr_push_align(ndr, 5));
10479                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
10480                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10481                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
10482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
10483                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
10484                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10485         }
10486         if (ndr_flags & NDR_BUFFERS) {
10487                 if (r->dsa_obj_dn) {
10488                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10489                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10490                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10491                         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));
10492                 }
10493         }
10494         return NDR_ERR_SUCCESS;
10495 }
10496
10497 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
10498 {
10499         uint32_t _ptr_dsa_obj_dn;
10500         TALLOC_CTX *_mem_save_dsa_obj_dn_0;
10501         if (ndr_flags & NDR_SCALARS) {
10502                 NDR_CHECK(ndr_pull_align(ndr, 5));
10503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
10504                 if (_ptr_dsa_obj_dn) {
10505                         NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
10506                 } else {
10507                         r->dsa_obj_dn = NULL;
10508                 }
10509                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10510                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
10511                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
10512                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
10513                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10514         }
10515         if (ndr_flags & NDR_BUFFERS) {
10516                 if (r->dsa_obj_dn) {
10517                         _mem_save_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10518                         NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
10519                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
10520                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
10521                         if (ndr_get_array_length(ndr, &r->dsa_obj_dn) > ndr_get_array_size(ndr, &r->dsa_obj_dn)) {
10522                                 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));
10523                         }
10524                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t)));
10525                         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));
10526                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
10527                 }
10528         }
10529         return NDR_ERR_SUCCESS;
10530 }
10531
10532 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailure(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailure *r)
10533 {
10534         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailure");
10535         ndr->depth++;
10536         ndr_print_ptr(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10537         ndr->depth++;
10538         if (r->dsa_obj_dn) {
10539                 ndr_print_string(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10540         }
10541         ndr->depth--;
10542         ndr_print_GUID(ndr, "dsa_obj_guid", &r->dsa_obj_guid);
10543         ndr_print_NTTIME(ndr, "first_failure", r->first_failure);
10544         ndr_print_uint32(ndr, "num_failures", r->num_failures);
10545         ndr_print_WERROR(ndr, "last_result", r->last_result);
10546         ndr->depth--;
10547 }
10548
10549 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10550 {
10551         uint32_t cntr_array_0;
10552         if (ndr_flags & NDR_SCALARS) {
10553                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10554                 NDR_CHECK(ndr_push_align(ndr, 5));
10555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10557                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10558                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10559                 }
10560                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10561         }
10562         if (ndr_flags & NDR_BUFFERS) {
10563                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10564                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10565                 }
10566         }
10567         return NDR_ERR_SUCCESS;
10568 }
10569
10570 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10571 {
10572         uint32_t cntr_array_0;
10573         TALLOC_CTX *_mem_save_array_0;
10574         if (ndr_flags & NDR_SCALARS) {
10575                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10576                 NDR_CHECK(ndr_pull_align(ndr, 5));
10577                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10578                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10579                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10580                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10581                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10582                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10583                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10584                 }
10585                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10586                 if (r->array) {
10587                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10588                 }
10589                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10590         }
10591         if (ndr_flags & NDR_BUFFERS) {
10592                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10593                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10594                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10595                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10596                 }
10597                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10598         }
10599         return NDR_ERR_SUCCESS;
10600 }
10601
10602 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10603 {
10604         uint32_t cntr_array_0;
10605         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailuresCtr");
10606         ndr->depth++;
10607         ndr_print_uint32(ndr, "count", r->count);
10608         ndr_print_uint32(ndr, "reserved", r->reserved);
10609         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10610         ndr->depth++;
10611         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10612                 char *idx_0=NULL;
10613                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10614                         ndr_print_drsuapi_DsReplicaKccDsaFailure(ndr, "array", &r->array[cntr_array_0]);
10615                         free(idx_0);
10616                 }
10617         }
10618         ndr->depth--;
10619         ndr->depth--;
10620 }
10621
10622 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
10623 {
10624         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
10625         return NDR_ERR_SUCCESS;
10626 }
10627
10628 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
10629 {
10630         uint16_t v;
10631         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
10632         *r = v;
10633         return NDR_ERR_SUCCESS;
10634 }
10635
10636 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaOpType r)
10637 {
10638         const char *val = NULL;
10639
10640         switch (r) {
10641                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: val = "DRSUAPI_DS_REPLICA_OP_TYPE_SYNC"; break;
10642                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: val = "DRSUAPI_DS_REPLICA_OP_TYPE_ADD"; break;
10643                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: val = "DRSUAPI_DS_REPLICA_OP_TYPE_DELETE"; break;
10644                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: val = "DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY"; break;
10645                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: val = "DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS"; break;
10646         }
10647         ndr_print_enum(ndr, name, "ENUM", val, r);
10648 }
10649
10650 static enum ndr_err_code ndr_push_drsuapi_DsRplicaOpOptions(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRplicaOpOptions *r)
10651 {
10652         if (ndr_flags & NDR_SCALARS) {
10653                 int level = ndr_push_get_switch_value(ndr, r);
10654                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, level));
10655                 NDR_CHECK(ndr_push_union_align(ndr, 4));
10656                 switch (level) {
10657                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
10658                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->sync));
10659                         break; }
10660
10661                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
10662                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->add));
10663                         break; }
10664
10665                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
10666                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->op_delete));
10667                         break; }
10668
10669                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
10670                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->modify));
10671                         break; }
10672
10673                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
10674                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->update_refs));
10675                         break; }
10676
10677                         default: {
10678                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
10679                         break; }
10680
10681                 }
10682         }
10683         if (ndr_flags & NDR_BUFFERS) {
10684                 int level = ndr_push_get_switch_value(ndr, r);
10685                 switch (level) {
10686                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10687                         break;
10688
10689                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10690                         break;
10691
10692                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10693                         break;
10694
10695                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10696                         break;
10697
10698                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10699                         break;
10700
10701                         default:
10702                         break;
10703
10704                 }
10705         }
10706         return NDR_ERR_SUCCESS;
10707 }
10708
10709 static enum ndr_err_code ndr_pull_drsuapi_DsRplicaOpOptions(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRplicaOpOptions *r)
10710 {
10711         int level;
10712         uint16_t _level;
10713         level = ndr_pull_get_switch_value(ndr, r);
10714         if (ndr_flags & NDR_SCALARS) {
10715                 NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
10716                 if (_level != level) {
10717                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10718                 }
10719                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
10720                 switch (level) {
10721                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
10722                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->sync));
10723                         break; }
10724
10725                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
10726                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->add));
10727                         break; }
10728
10729                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
10730                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->op_delete));
10731                         break; }
10732
10733                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
10734                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->modify));
10735                         break; }
10736
10737                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
10738                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->update_refs));
10739                         break; }
10740
10741                         default: {
10742                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
10743                         break; }
10744
10745                 }
10746         }
10747         if (ndr_flags & NDR_BUFFERS) {
10748                 switch (level) {
10749                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10750                         break;
10751
10752                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10753                         break;
10754
10755                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10756                         break;
10757
10758                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10759                         break;
10760
10761                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10762                         break;
10763
10764                         default:
10765                         break;
10766
10767                 }
10768         }
10769         return NDR_ERR_SUCCESS;
10770 }
10771
10772 _PUBLIC_ void ndr_print_drsuapi_DsRplicaOpOptions(struct ndr_print *ndr, const char *name, const union drsuapi_DsRplicaOpOptions *r)
10773 {
10774         int level;
10775         level = ndr_print_get_switch_value(ndr, r);
10776         ndr_print_union(ndr, name, level, "drsuapi_DsRplicaOpOptions");
10777         switch (level) {
10778                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10779                         ndr_print_drsuapi_DsReplicaSyncOptions(ndr, "sync", r->sync);
10780                 break;
10781
10782                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10783                         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "add", r->add);
10784                 break;
10785
10786                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10787                         ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "op_delete", r->op_delete);
10788                 break;
10789
10790                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10791                         ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "modify", r->modify);
10792                 break;
10793
10794                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10795                         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "update_refs", r->update_refs);
10796                 break;
10797
10798                 default:
10799                         ndr_print_uint32(ndr, "unknown", r->unknown);
10800                 break;
10801
10802         }
10803 }
10804
10805 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
10806 {
10807         if (ndr_flags & NDR_SCALARS) {
10808                 NDR_CHECK(ndr_push_align(ndr, 5));
10809                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
10810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
10811                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
10812                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
10813                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->options, r->operation_type));
10814                 NDR_CHECK(ndr_push_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
10815                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
10816                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
10817                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
10818                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10819                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10820                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10821         }
10822         if (ndr_flags & NDR_BUFFERS) {
10823                 if (r->nc_dn) {
10824                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10825                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10826                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10827                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10828                 }
10829                 if (r->remote_dsa_obj_dn) {
10830                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10831                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10832                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10833                         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));
10834                 }
10835                 if (r->remote_dsa_address) {
10836                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10837                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10838                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10839                         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));
10840                 }
10841         }
10842         return NDR_ERR_SUCCESS;
10843 }
10844
10845 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
10846 {
10847         uint32_t _ptr_nc_dn;
10848         TALLOC_CTX *_mem_save_nc_dn_0;
10849         uint32_t _ptr_remote_dsa_obj_dn;
10850         TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
10851         uint32_t _ptr_remote_dsa_address;
10852         TALLOC_CTX *_mem_save_remote_dsa_address_0;
10853         if (ndr_flags & NDR_SCALARS) {
10854                 NDR_CHECK(ndr_pull_align(ndr, 5));
10855                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
10856                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
10857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
10858                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
10859                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->options, r->operation_type));
10860                 NDR_CHECK(ndr_pull_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
10861                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
10862                 if (_ptr_nc_dn) {
10863                         NDR_PULL_ALLOC(ndr, r->nc_dn);
10864                 } else {
10865                         r->nc_dn = NULL;
10866                 }
10867                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_obj_dn));
10868                 if (_ptr_remote_dsa_obj_dn) {
10869                         NDR_PULL_ALLOC(ndr, r->remote_dsa_obj_dn);
10870                 } else {
10871                         r->remote_dsa_obj_dn = NULL;
10872                 }
10873                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_address));
10874                 if (_ptr_remote_dsa_address) {
10875                         NDR_PULL_ALLOC(ndr, r->remote_dsa_address);
10876                 } else {
10877                         r->remote_dsa_address = NULL;
10878                 }
10879                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10880                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10881                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10882         }
10883         if (ndr_flags & NDR_BUFFERS) {
10884                 if (r->nc_dn) {
10885                         _mem_save_nc_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10886                         NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
10887                         NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
10888                         NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
10889                         if (ndr_get_array_length(ndr, &r->nc_dn) > ndr_get_array_size(ndr, &r->nc_dn)) {
10890                                 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));
10891                         }
10892                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t)));
10893                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t), CH_UTF16));
10894                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
10895                 }
10896                 if (r->remote_dsa_obj_dn) {
10897                         _mem_save_remote_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10898                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
10899                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
10900                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
10901                         if (ndr_get_array_length(ndr, &r->remote_dsa_obj_dn) > ndr_get_array_size(ndr, &r->remote_dsa_obj_dn)) {
10902                                 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));
10903                         }
10904                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t)));
10905                         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));
10906                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
10907                 }
10908                 if (r->remote_dsa_address) {
10909                         _mem_save_remote_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10910                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
10911                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
10912                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
10913                         if (ndr_get_array_length(ndr, &r->remote_dsa_address) > ndr_get_array_size(ndr, &r->remote_dsa_address)) {
10914                                 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));
10915                         }
10916                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t)));
10917                         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));
10918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
10919                 }
10920         }
10921         return NDR_ERR_SUCCESS;
10922 }
10923
10924 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOp *r)
10925 {
10926         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOp");
10927         ndr->depth++;
10928         ndr_print_NTTIME(ndr, "operation_start", r->operation_start);
10929         ndr_print_uint32(ndr, "serial_num", r->serial_num);
10930         ndr_print_uint32(ndr, "priority", r->priority);
10931         ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
10932         ndr_print_set_switch_value(ndr, &r->options, r->operation_type);
10933         ndr_print_drsuapi_DsRplicaOpOptions(ndr, "options", &r->options);
10934         ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
10935         ndr->depth++;
10936         if (r->nc_dn) {
10937                 ndr_print_string(ndr, "nc_dn", r->nc_dn);
10938         }
10939         ndr->depth--;
10940         ndr_print_ptr(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10941         ndr->depth++;
10942         if (r->remote_dsa_obj_dn) {
10943                 ndr_print_string(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10944         }
10945         ndr->depth--;
10946         ndr_print_ptr(ndr, "remote_dsa_address", r->remote_dsa_address);
10947         ndr->depth++;
10948         if (r->remote_dsa_address) {
10949                 ndr_print_string(ndr, "remote_dsa_address", r->remote_dsa_address);
10950         }
10951         ndr->depth--;
10952         ndr_print_GUID(ndr, "nc_obj_guid", &r->nc_obj_guid);
10953         ndr_print_GUID(ndr, "remote_dsa_obj_guid", &r->remote_dsa_obj_guid);
10954         ndr->depth--;
10955 }
10956
10957 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOpCtr *r)
10958 {
10959         uint32_t cntr_array_0;
10960         if (ndr_flags & NDR_SCALARS) {
10961                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10962                 NDR_CHECK(ndr_push_align(ndr, 5));
10963                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
10964                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10965                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10966                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10967                 }
10968                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10969         }
10970         if (ndr_flags & NDR_BUFFERS) {
10971                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10972                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10973                 }
10974         }
10975         return NDR_ERR_SUCCESS;
10976 }
10977
10978 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
10979 {
10980         uint32_t cntr_array_0;
10981         TALLOC_CTX *_mem_save_array_0;
10982         if (ndr_flags & NDR_SCALARS) {
10983                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10984                 NDR_CHECK(ndr_pull_align(ndr, 5));
10985                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
10986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10987                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10988                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10989                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10990                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10991                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10992                 }
10993                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10994                 if (r->array) {
10995                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10996                 }
10997                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10998         }
10999         if (ndr_flags & NDR_BUFFERS) {
11000                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11001                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11002                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11003                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11004                 }
11005                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11006         }
11007         return NDR_ERR_SUCCESS;
11008 }
11009
11010 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOpCtr *r)
11011 {
11012         uint32_t cntr_array_0;
11013         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOpCtr");
11014         ndr->depth++;
11015         ndr_print_NTTIME(ndr, "time", r->time);
11016         ndr_print_uint32(ndr, "count", r->count);
11017         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11018         ndr->depth++;
11019         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11020                 char *idx_0=NULL;
11021                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11022                         ndr_print_drsuapi_DsReplicaOp(ndr, "array", &r->array[cntr_array_0]);
11023                         free(idx_0);
11024                 }
11025         }
11026         ndr->depth--;
11027         ndr->depth--;
11028 }
11029
11030 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData *r)
11031 {
11032         if (ndr_flags & NDR_SCALARS) {
11033                 NDR_CHECK(ndr_push_align(ndr, 8));
11034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11036                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11038                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11039                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11041                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11042                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11043                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11044                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11045                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11046         }
11047         if (ndr_flags & NDR_BUFFERS) {
11048                 if (r->attribute_name) {
11049                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11050                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11051                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11052                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11053                 }
11054                 if (r->object_dn) {
11055                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11056                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11057                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11058                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11059                 }
11060                 if (r->binary) {
11061                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11062                 }
11063         }
11064         return NDR_ERR_SUCCESS;
11065 }
11066
11067 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
11068 {
11069         uint32_t _ptr_attribute_name;
11070         TALLOC_CTX *_mem_save_attribute_name_0;
11071         uint32_t _ptr_object_dn;
11072         TALLOC_CTX *_mem_save_object_dn_0;
11073         uint32_t _ptr_binary;
11074         TALLOC_CTX *_mem_save_binary_0;
11075         if (ndr_flags & NDR_SCALARS) {
11076                 NDR_CHECK(ndr_pull_align(ndr, 8));
11077                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11078                 if (_ptr_attribute_name) {
11079                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11080                 } else {
11081                         r->attribute_name = NULL;
11082                 }
11083                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11084                 if (_ptr_object_dn) {
11085                         NDR_PULL_ALLOC(ndr, r->object_dn);
11086                 } else {
11087                         r->object_dn = NULL;
11088                 }
11089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11090                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11091                 if (_ptr_binary) {
11092                         NDR_PULL_ALLOC(ndr, r->binary);
11093                 } else {
11094                         r->binary = NULL;
11095                 }
11096                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11097                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11098                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11099                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11100                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11101                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11102                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11103                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11104         }
11105         if (ndr_flags & NDR_BUFFERS) {
11106                 if (r->attribute_name) {
11107                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11108                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11109                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11110                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11111                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11112                                 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));
11113                         }
11114                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11115                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11116                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11117                 }
11118                 if (r->object_dn) {
11119                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11120                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11121                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11122                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11123                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11124                                 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));
11125                         }
11126                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11127                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11128                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11129                 }
11130                 if (r->binary) {
11131                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11132                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11133                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11134                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11135                 }
11136         }
11137         return NDR_ERR_SUCCESS;
11138 }
11139
11140 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData *r)
11141 {
11142         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData");
11143         ndr->depth++;
11144         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11145         ndr->depth++;
11146         if (r->attribute_name) {
11147                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11148         }
11149         ndr->depth--;
11150         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11151         ndr->depth++;
11152         if (r->object_dn) {
11153                 ndr_print_string(ndr, "object_dn", r->object_dn);
11154         }
11155         ndr->depth--;
11156         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);
11157         ndr_print_ptr(ndr, "binary", r->binary);
11158         ndr->depth++;
11159         if (r->binary) {
11160                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11161         }
11162         ndr->depth--;
11163         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11164         ndr_print_NTTIME(ndr, "created", r->created);
11165         ndr_print_uint32(ndr, "version", r->version);
11166         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11167         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11168         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11169         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11170         ndr->depth--;
11171 }
11172
11173 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
11174 {
11175         uint32_t cntr_array_0;
11176         if (ndr_flags & NDR_SCALARS) {
11177                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11178                 NDR_CHECK(ndr_push_align(ndr, 8));
11179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11180                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11181                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11182                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11183                 }
11184                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11185         }
11186         if (ndr_flags & NDR_BUFFERS) {
11187                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11188                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11189                 }
11190         }
11191         return NDR_ERR_SUCCESS;
11192 }
11193
11194 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
11195 {
11196         uint32_t cntr_array_0;
11197         TALLOC_CTX *_mem_save_array_0;
11198         if (ndr_flags & NDR_SCALARS) {
11199                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11200                 NDR_CHECK(ndr_pull_align(ndr, 8));
11201                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11202                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11203                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11204                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11205                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11206                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11207                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11208                 }
11209                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11210                 if (r->array) {
11211                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11212                 }
11213                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11214         }
11215         if (ndr_flags & NDR_BUFFERS) {
11216                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11217                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11218                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11219                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11220                 }
11221                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11222         }
11223         return NDR_ERR_SUCCESS;
11224 }
11225
11226 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
11227 {
11228         uint32_t cntr_array_0;
11229         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaDataCtr");
11230         ndr->depth++;
11231         ndr_print_uint32(ndr, "count", r->count);
11232         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11233         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11234         ndr->depth++;
11235         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11236                 char *idx_0=NULL;
11237                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11238                         ndr_print_drsuapi_DsReplicaAttrValMetaData(ndr, "array", &r->array[cntr_array_0]);
11239                         free(idx_0);
11240                 }
11241         }
11242         ndr->depth--;
11243         ndr->depth--;
11244 }
11245
11246 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2Ctr *r)
11247 {
11248         uint32_t cntr_array_0;
11249         if (ndr_flags & NDR_SCALARS) {
11250                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11251                 NDR_CHECK(ndr_push_align(ndr, 8));
11252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11253                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11254                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11255                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11256                 }
11257                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11258         }
11259         if (ndr_flags & NDR_BUFFERS) {
11260         }
11261         return NDR_ERR_SUCCESS;
11262 }
11263
11264 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
11265 {
11266         uint32_t cntr_array_0;
11267         TALLOC_CTX *_mem_save_array_0;
11268         if (ndr_flags & NDR_SCALARS) {
11269                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11270                 NDR_CHECK(ndr_pull_align(ndr, 8));
11271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11272                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11273                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11274                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11275                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11276                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11277                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11278                 }
11279                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11280                 if (r->array) {
11281                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11282                 }
11283                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11284         }
11285         if (ndr_flags & NDR_BUFFERS) {
11286         }
11287         return NDR_ERR_SUCCESS;
11288 }
11289
11290 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2Ctr *r)
11291 {
11292         uint32_t cntr_array_0;
11293         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2Ctr");
11294         ndr->depth++;
11295         ndr_print_uint32(ndr, "count", r->count);
11296         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11297         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11298         ndr->depth++;
11299         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11300                 char *idx_0=NULL;
11301                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11302                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "array", &r->array[cntr_array_0]);
11303                         free(idx_0);
11304                 }
11305         }
11306         ndr->depth--;
11307         ndr->depth--;
11308 }
11309
11310 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3 *r)
11311 {
11312         if (ndr_flags & NDR_SCALARS) {
11313                 NDR_CHECK(ndr_push_align(ndr, 8));
11314                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11315                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
11316                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
11317                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
11318                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11319         }
11320         if (ndr_flags & NDR_BUFFERS) {
11321                 if (r->source_dsa_obj_dn) {
11322                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11323                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11324                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11325                         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));
11326                 }
11327         }
11328         return NDR_ERR_SUCCESS;
11329 }
11330
11331 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
11332 {
11333         uint32_t _ptr_source_dsa_obj_dn;
11334         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
11335         if (ndr_flags & NDR_SCALARS) {
11336                 NDR_CHECK(ndr_pull_align(ndr, 8));
11337                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11338                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
11339                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
11340                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
11341                 if (_ptr_source_dsa_obj_dn) {
11342                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
11343                 } else {
11344                         r->source_dsa_obj_dn = NULL;
11345                 }
11346                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11347         }
11348         if (ndr_flags & NDR_BUFFERS) {
11349                 if (r->source_dsa_obj_dn) {
11350                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11351                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
11352                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
11353                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
11354                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
11355                                 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));
11356                         }
11357                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
11358                         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));
11359                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
11360                 }
11361         }
11362         return NDR_ERR_SUCCESS;
11363 }
11364
11365 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3 *r)
11366 {
11367         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3");
11368         ndr->depth++;
11369         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
11370         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
11371         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
11372         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11373         ndr->depth++;
11374         if (r->source_dsa_obj_dn) {
11375                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11376         }
11377         ndr->depth--;
11378         ndr->depth--;
11379 }
11380
11381 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3Ctr *r)
11382 {
11383         uint32_t cntr_array_0;
11384         if (ndr_flags & NDR_SCALARS) {
11385                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11386                 NDR_CHECK(ndr_push_align(ndr, 8));
11387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11388                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11389                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11390                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11391                 }
11392                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11393         }
11394         if (ndr_flags & NDR_BUFFERS) {
11395                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11396                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11397                 }
11398         }
11399         return NDR_ERR_SUCCESS;
11400 }
11401
11402 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
11403 {
11404         uint32_t cntr_array_0;
11405         TALLOC_CTX *_mem_save_array_0;
11406         if (ndr_flags & NDR_SCALARS) {
11407                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11408                 NDR_CHECK(ndr_pull_align(ndr, 8));
11409                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11410                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11411                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11412                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11413                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11414                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11415                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11416                 }
11417                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11418                 if (r->array) {
11419                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11420                 }
11421                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11422         }
11423         if (ndr_flags & NDR_BUFFERS) {
11424                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11425                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11426                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11427                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11428                 }
11429                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11430         }
11431         return NDR_ERR_SUCCESS;
11432 }
11433
11434 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3Ctr *r)
11435 {
11436         uint32_t cntr_array_0;
11437         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3Ctr");
11438         ndr->depth++;
11439         ndr_print_uint32(ndr, "count", r->count);
11440         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11441         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11442         ndr->depth++;
11443         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11444                 char *idx_0=NULL;
11445                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11446                         ndr_print_drsuapi_DsReplicaCursor3(ndr, "array", &r->array[cntr_array_0]);
11447                         free(idx_0);
11448                 }
11449         }
11450         ndr->depth--;
11451         ndr->depth--;
11452 }
11453
11454 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2 *r)
11455 {
11456         if (ndr_flags & NDR_SCALARS) {
11457                 NDR_CHECK(ndr_push_align(ndr, 8));
11458                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11460                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11461                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11462                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11463                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11464                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11465                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11466         }
11467         if (ndr_flags & NDR_BUFFERS) {
11468                 if (r->attribute_name) {
11469                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11470                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11471                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11472                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11473                 }
11474                 if (r->originating_dsa_dn) {
11475                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11476                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11477                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11478                         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));
11479                 }
11480         }
11481         return NDR_ERR_SUCCESS;
11482 }
11483
11484 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
11485 {
11486         uint32_t _ptr_attribute_name;
11487         TALLOC_CTX *_mem_save_attribute_name_0;
11488         uint32_t _ptr_originating_dsa_dn;
11489         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11490         if (ndr_flags & NDR_SCALARS) {
11491                 NDR_CHECK(ndr_pull_align(ndr, 8));
11492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11493                 if (_ptr_attribute_name) {
11494                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11495                 } else {
11496                         r->attribute_name = NULL;
11497                 }
11498                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11499                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11500                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11501                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11502                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11504                 if (_ptr_originating_dsa_dn) {
11505                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11506                 } else {
11507                         r->originating_dsa_dn = NULL;
11508                 }
11509                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11510         }
11511         if (ndr_flags & NDR_BUFFERS) {
11512                 if (r->attribute_name) {
11513                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11514                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11515                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11516                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11517                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11518                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->attribute_name), ndr_get_array_length(ndr, &r->attribute_name));
11519                         }
11520                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11521                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11522                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11523                 }
11524                 if (r->originating_dsa_dn) {
11525                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11526                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11527                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11528                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11529                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11530                                 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));
11531                         }
11532                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11533                         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));
11534                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11535                 }
11536         }
11537         return NDR_ERR_SUCCESS;
11538 }
11539
11540 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2 *r)
11541 {
11542         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2");
11543         ndr->depth++;
11544         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11545         ndr->depth++;
11546         if (r->attribute_name) {
11547                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11548         }
11549         ndr->depth--;
11550         ndr_print_uint32(ndr, "version", r->version);
11551         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11552         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11553         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11554         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11555         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11556         ndr->depth++;
11557         if (r->originating_dsa_dn) {
11558                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11559         }
11560         ndr->depth--;
11561         ndr->depth--;
11562 }
11563
11564 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11565 {
11566         uint32_t cntr_array_0;
11567         if (ndr_flags & NDR_SCALARS) {
11568                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11569                 NDR_CHECK(ndr_push_align(ndr, 8));
11570                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11571                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11572                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11573                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11574                 }
11575                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11576         }
11577         if (ndr_flags & NDR_BUFFERS) {
11578                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11579                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11580                 }
11581         }
11582         return NDR_ERR_SUCCESS;
11583 }
11584
11585 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11586 {
11587         uint32_t cntr_array_0;
11588         TALLOC_CTX *_mem_save_array_0;
11589         if (ndr_flags & NDR_SCALARS) {
11590                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11591                 NDR_CHECK(ndr_pull_align(ndr, 8));
11592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11593                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11594                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11595                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11596                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11597                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11598                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11599                 }
11600                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11601                 if (r->array) {
11602                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11603                 }
11604                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11605         }
11606         if (ndr_flags & NDR_BUFFERS) {
11607                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11608                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11609                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11610                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11611                 }
11612                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11613         }
11614         return NDR_ERR_SUCCESS;
11615 }
11616
11617 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11618 {
11619         uint32_t cntr_array_0;
11620         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2Ctr");
11621         ndr->depth++;
11622         ndr_print_uint32(ndr, "count", r->count);
11623         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11624         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11625         ndr->depth++;
11626         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11627                 char *idx_0=NULL;
11628                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11629                         ndr_print_drsuapi_DsReplicaObjMetaData2(ndr, "array", &r->array[cntr_array_0]);
11630                         free(idx_0);
11631                 }
11632         }
11633         ndr->depth--;
11634         ndr->depth--;
11635 }
11636
11637 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11638 {
11639         if (ndr_flags & NDR_SCALARS) {
11640                 NDR_CHECK(ndr_push_align(ndr, 8));
11641                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11642                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11643                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11644                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11645                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11646                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11648                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11649                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11650                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11651                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11652                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11653                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11654         }
11655         if (ndr_flags & NDR_BUFFERS) {
11656                 if (r->attribute_name) {
11657                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11658                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11659                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11660                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11661                 }
11662                 if (r->object_dn) {
11663                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11664                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11665                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11666                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11667                 }
11668                 if (r->binary) {
11669                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11670                 }
11671                 if (r->originating_dsa_dn) {
11672                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11673                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11674                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11675                         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));
11676                 }
11677         }
11678         return NDR_ERR_SUCCESS;
11679 }
11680
11681 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
11682 {
11683         uint32_t _ptr_attribute_name;
11684         TALLOC_CTX *_mem_save_attribute_name_0;
11685         uint32_t _ptr_object_dn;
11686         TALLOC_CTX *_mem_save_object_dn_0;
11687         uint32_t _ptr_binary;
11688         TALLOC_CTX *_mem_save_binary_0;
11689         uint32_t _ptr_originating_dsa_dn;
11690         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11691         if (ndr_flags & NDR_SCALARS) {
11692                 NDR_CHECK(ndr_pull_align(ndr, 8));
11693                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11694                 if (_ptr_attribute_name) {
11695                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11696                 } else {
11697                         r->attribute_name = NULL;
11698                 }
11699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11700                 if (_ptr_object_dn) {
11701                         NDR_PULL_ALLOC(ndr, r->object_dn);
11702                 } else {
11703                         r->object_dn = NULL;
11704                 }
11705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11706                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11707                 if (_ptr_binary) {
11708                         NDR_PULL_ALLOC(ndr, r->binary);
11709                 } else {
11710                         r->binary = NULL;
11711                 }
11712                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11713                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11715                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11716                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11717                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11718                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11719                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11720                 if (_ptr_originating_dsa_dn) {
11721                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11722                 } else {
11723                         r->originating_dsa_dn = NULL;
11724                 }
11725                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11726         }
11727         if (ndr_flags & NDR_BUFFERS) {
11728                 if (r->attribute_name) {
11729                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11730                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11731                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11732                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11733                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11734                                 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));
11735                         }
11736                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11737                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11738                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11739                 }
11740                 if (r->object_dn) {
11741                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11742                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11743                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11744                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11745                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11746                                 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));
11747                         }
11748                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11749                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11750                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11751                 }
11752                 if (r->binary) {
11753                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11754                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11755                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11756                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11757                 }
11758                 if (r->originating_dsa_dn) {
11759                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11760                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11761                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11762                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11763                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11764                                 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));
11765                         }
11766                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11767                         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));
11768                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11769                 }
11770         }
11771         return NDR_ERR_SUCCESS;
11772 }
11773
11774 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11775 {
11776         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2");
11777         ndr->depth++;
11778         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11779         ndr->depth++;
11780         if (r->attribute_name) {
11781                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11782         }
11783         ndr->depth--;
11784         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11785         ndr->depth++;
11786         if (r->object_dn) {
11787                 ndr_print_string(ndr, "object_dn", r->object_dn);
11788         }
11789         ndr->depth--;
11790         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);
11791         ndr_print_ptr(ndr, "binary", r->binary);
11792         ndr->depth++;
11793         if (r->binary) {
11794                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11795         }
11796         ndr->depth--;
11797         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11798         ndr_print_NTTIME(ndr, "created", r->created);
11799         ndr_print_uint32(ndr, "version", r->version);
11800         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11801         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11802         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11803         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11804         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11805         ndr->depth++;
11806         if (r->originating_dsa_dn) {
11807                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11808         }
11809         ndr->depth--;
11810         ndr->depth--;
11811 }
11812
11813 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11814 {
11815         uint32_t cntr_array_0;
11816         if (ndr_flags & NDR_SCALARS) {
11817                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11818                 NDR_CHECK(ndr_push_align(ndr, 8));
11819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11820                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11821                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11822                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11823                 }
11824                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11825         }
11826         if (ndr_flags & NDR_BUFFERS) {
11827                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11828                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11829                 }
11830         }
11831         return NDR_ERR_SUCCESS;
11832 }
11833
11834 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11835 {
11836         uint32_t cntr_array_0;
11837         TALLOC_CTX *_mem_save_array_0;
11838         if (ndr_flags & NDR_SCALARS) {
11839                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11840                 NDR_CHECK(ndr_pull_align(ndr, 8));
11841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11842                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11843                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11844                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11845                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11846                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11847                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11848                 }
11849                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11850                 if (r->array) {
11851                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11852                 }
11853                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11854         }
11855         if (ndr_flags & NDR_BUFFERS) {
11856                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11857                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11858                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11859                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11860                 }
11861                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11862         }
11863         return NDR_ERR_SUCCESS;
11864 }
11865
11866 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11867 {
11868         uint32_t cntr_array_0;
11869         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2Ctr");
11870         ndr->depth++;
11871         ndr_print_uint32(ndr, "count", r->count);
11872         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11873         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11874         ndr->depth++;
11875         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11876                 char *idx_0=NULL;
11877                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11878                         ndr_print_drsuapi_DsReplicaAttrValMetaData2(ndr, "array", &r->array[cntr_array_0]);
11879                         free(idx_0);
11880                 }
11881         }
11882         ndr->depth--;
11883         ndr->depth--;
11884 }
11885
11886 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04 *r)
11887 {
11888         if (ndr_flags & NDR_SCALARS) {
11889                 NDR_CHECK(ndr_push_align(ndr, 8));
11890                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u1));
11891                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11892                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11893                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11894                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->bind_time));
11895                 {
11896                         uint32_t _flags_save_ipv4address = ndr->flags;
11897                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11898                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
11899                         ndr->flags = _flags_save_ipv4address;
11900                 }
11901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11902                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11903         }
11904         if (ndr_flags & NDR_BUFFERS) {
11905         }
11906         return NDR_ERR_SUCCESS;
11907 }
11908
11909 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04 *r)
11910 {
11911         if (ndr_flags & NDR_SCALARS) {
11912                 NDR_CHECK(ndr_pull_align(ndr, 8));
11913                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u1));
11914                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11916                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11917                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->bind_time));
11918                 {
11919                         uint32_t _flags_save_ipv4address = ndr->flags;
11920                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11921                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
11922                         ndr->flags = _flags_save_ipv4address;
11923                 }
11924                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11925                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11926         }
11927         if (ndr_flags & NDR_BUFFERS) {
11928         }
11929         return NDR_ERR_SUCCESS;
11930 }
11931
11932 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04 *r)
11933 {
11934         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04");
11935         ndr->depth++;
11936         ndr_print_hyper(ndr, "u1", r->u1);
11937         ndr_print_uint32(ndr, "u2", r->u2);
11938         ndr_print_uint32(ndr, "u3", r->u3);
11939         ndr_print_GUID(ndr, "bind_guid", &r->bind_guid);
11940         ndr_print_NTTIME_1sec(ndr, "bind_time", r->bind_time);
11941         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
11942         ndr_print_uint32(ndr, "u5", r->u5);
11943         ndr->depth--;
11944 }
11945
11946 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04Ctr *r)
11947 {
11948         uint32_t cntr_array_0;
11949         if (ndr_flags & NDR_SCALARS) {
11950                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11951                 NDR_CHECK(ndr_push_align(ndr, 8));
11952                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11953                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11954                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11955                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11956                 }
11957                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11958         }
11959         if (ndr_flags & NDR_BUFFERS) {
11960         }
11961         return NDR_ERR_SUCCESS;
11962 }
11963
11964 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
11965 {
11966         uint32_t cntr_array_0;
11967         TALLOC_CTX *_mem_save_array_0;
11968         if (ndr_flags & NDR_SCALARS) {
11969                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11970                 NDR_CHECK(ndr_pull_align(ndr, 8));
11971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11972                 if (r->count > 10000) {
11973                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11974                 }
11975                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11976                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11977                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11978                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11979                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11980                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11981                 }
11982                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11983                 if (r->array) {
11984                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11985                 }
11986                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11987         }
11988         if (ndr_flags & NDR_BUFFERS) {
11989         }
11990         return NDR_ERR_SUCCESS;
11991 }
11992
11993 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04Ctr *r)
11994 {
11995         uint32_t cntr_array_0;
11996         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04Ctr");
11997         ndr->depth++;
11998         ndr_print_uint32(ndr, "count", r->count);
11999         ndr_print_uint32(ndr, "reserved", r->reserved);
12000         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
12001         ndr->depth++;
12002         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
12003                 char *idx_0=NULL;
12004                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
12005                         ndr_print_drsuapi_DsReplicaConnection04(ndr, "array", &r->array[cntr_array_0]);
12006                         free(idx_0);
12007                 }
12008         }
12009         ndr->depth--;
12010         ndr->depth--;
12011 }
12012
12013 static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06 *r)
12014 {
12015         if (ndr_flags & NDR_SCALARS) {
12016                 NDR_CHECK(ndr_push_align(ndr, 8));
12017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str1));
12018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u1));
12019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
12020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
12021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u4));
12022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
12023                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
12024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
12025                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12026         }
12027         if (ndr_flags & NDR_BUFFERS) {
12028                 if (r->str1) {
12029                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
12030                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
12031                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
12032                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12033                 }
12034         }
12035         return NDR_ERR_SUCCESS;
12036 }
12037
12038 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
12039 {
12040         uint32_t _ptr_str1;
12041         TALLOC_CTX *_mem_save_str1_0;
12042         if (ndr_flags & NDR_SCALARS) {
12043                 NDR_CHECK(ndr_pull_align(ndr, 8));
12044                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str1));
12045                 if (_ptr_str1) {
12046                         NDR_PULL_ALLOC(ndr, r->str1);
12047                 } else {
12048                         r->str1 = NULL;
12049                 }
12050                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
12051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
12052                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
12053                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u4));
12054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
12055                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
12056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
12057                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12058         }
12059         if (ndr_flags & NDR_BUFFERS) {
12060                 if (r->str1) {
12061                         _mem_save_str1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12062                         NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
12063                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
12064                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
12065                         if (ndr_get_array_length(ndr, &r->str1) > ndr_get_array_size(ndr, &r->str1)) {
12066                                 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));
12067                         }
12068                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t)));
12069                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t), CH_UTF16));
12070                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
12071                 }
12072         }
12073         return NDR_ERR_SUCCESS;
12074 }
12075
12076 _PUBLIC_ void ndr_print_drsuapi_DsReplica06(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06 *r)
12077 {
12078         ndr_print_struct(ndr, name, "drsuapi_DsReplica06");
12079         ndr->depth++;
12080         ndr_print_ptr(ndr, "str1", r->str1);
12081         ndr->depth++;
12082         if (r->str1) {
12083                 ndr_print_string(ndr, "str1", r->str1);
12084         }
12085         ndr->depth--;
12086         ndr_print_uint32(ndr, "u1", r->u1);
12087         ndr_print_uint32(ndr, "u2", r->u2);
12088         ndr_print_uint32(ndr, "u3", r->u3);
12089         ndr_print_uint32(ndr, "u4", r->u4);
12090         ndr_print_uint32(ndr, "u5", r->u5);
12091         ndr_print_hyper(ndr, "u6", r->u6);
12092         ndr_print_uint32(ndr, "u7", r->u7);
12093         ndr->depth--;
12094 }
12095
12096 static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06Ctr *r)
12097 {
12098         uint32_t cntr_array_0;
12099         if (ndr_flags & NDR_SCALARS) {
12100                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
12101                 NDR_CHECK(ndr_push_align(ndr, 8));
12102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
12104                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12105                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
12106                 }
12107                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12108         }
12109         if (ndr_flags & NDR_BUFFERS) {
12110                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12111                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
12112                 }
12113         }
12114         return NDR_ERR_SUCCESS;
12115 }
12116
12117 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *r)
12118 {
12119         uint32_t cntr_array_0;
12120         TALLOC_CTX *_mem_save_array_0;
12121         if (ndr_flags & NDR_SCALARS) {
12122                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
12123                 NDR_CHECK(ndr_pull_align(ndr, 8));
12124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
12125                 if (r->count > 256) {
12126                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12127                 }
12128                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
12129                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
12130                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12131                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12132                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12133                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
12134                 }
12135                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12136                 if (r->array) {
12137                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
12138                 }
12139                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12140         }
12141         if (ndr_flags & NDR_BUFFERS) {
12142                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12143                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12144                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12145                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
12146                 }
12147                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12148         }
12149         return NDR_ERR_SUCCESS;
12150 }
12151
12152 _PUBLIC_ void ndr_print_drsuapi_DsReplica06Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06Ctr *r)
12153 {
12154         uint32_t cntr_array_0;
12155         ndr_print_struct(ndr, name, "drsuapi_DsReplica06Ctr");
12156         ndr->depth++;
12157         ndr_print_uint32(ndr, "count", r->count);
12158         ndr_print_uint32(ndr, "reserved", r->reserved);
12159         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
12160         ndr->depth++;
12161         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
12162                 char *idx_0=NULL;
12163                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
12164                         ndr_print_drsuapi_DsReplica06(ndr, "array", &r->array[cntr_array_0]);
12165                         free(idx_0);
12166                 }
12167         }
12168         ndr->depth--;
12169         ndr->depth--;
12170 }
12171
12172 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaInfo *r)
12173 {
12174         if (ndr_flags & NDR_SCALARS) {
12175                 int level = ndr_push_get_switch_value(ndr, r);
12176                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
12177                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12178                 switch (level) {
12179                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12180                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
12181                         break; }
12182
12183                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12184                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors));
12185                         break; }
12186
12187                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12188                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata));
12189                         break; }
12190
12191                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12192                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connectfailures));
12193                         break; }
12194
12195                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12196                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linkfailures));
12197                         break; }
12198
12199                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12200                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pendingops));
12201                         break; }
12202
12203                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12204                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata));
12205                         break; }
12206
12207                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12208                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors2));
12209                         break; }
12210
12211                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12212                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors3));
12213                         break; }
12214
12215                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12216                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata2));
12217                         break; }
12218
12219                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12220                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata2));
12221                         break; }
12222
12223                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
12224                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours02));
12225                         break; }
12226
12227                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
12228                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connections04));
12229                         break; }
12230
12231                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
12232                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors05));
12233                         break; }
12234
12235                         case DRSUAPI_DS_REPLICA_INFO_06: {
12236                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->i06));
12237                         break; }
12238
12239                         default:
12240                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12241                 }
12242         }
12243         if (ndr_flags & NDR_BUFFERS) {
12244                 int level = ndr_push_get_switch_value(ndr, r);
12245                 switch (level) {
12246                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12247                                 if (r->neighbours) {
12248                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12249                                 }
12250                         break;
12251
12252                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12253                                 if (r->cursors) {
12254                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12255                                 }
12256                         break;
12257
12258                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12259                                 if (r->objmetadata) {
12260                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12261                                 }
12262                         break;
12263
12264                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12265                                 if (r->connectfailures) {
12266                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12267                                 }
12268                         break;
12269
12270                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12271                                 if (r->linkfailures) {
12272                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12273                                 }
12274                         break;
12275
12276                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12277                                 if (r->pendingops) {
12278                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12279                                 }
12280                         break;
12281
12282                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12283                                 if (r->attrvalmetadata) {
12284                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12285                                 }
12286                         break;
12287
12288                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12289                                 if (r->cursors2) {
12290                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12291                                 }
12292                         break;
12293
12294                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12295                                 if (r->cursors3) {
12296                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12297                                 }
12298                         break;
12299
12300                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12301                                 if (r->objmetadata2) {
12302                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12303                                 }
12304                         break;
12305
12306                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12307                                 if (r->attrvalmetadata2) {
12308                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12309                                 }
12310                         break;
12311
12312                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12313                                 if (r->neighbours02) {
12314                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12315                                 }
12316                         break;
12317
12318                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12319                                 if (r->connections04) {
12320                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12321                                 }
12322                         break;
12323
12324                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12325                                 if (r->cursors05) {
12326                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12327                                 }
12328                         break;
12329
12330                         case DRSUAPI_DS_REPLICA_INFO_06:
12331                                 if (r->i06) {
12332                                         NDR_CHECK(ndr_push_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12333                                 }
12334                         break;
12335
12336                         default:
12337                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12338                 }
12339         }
12340         return NDR_ERR_SUCCESS;
12341 }
12342
12343 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaInfo *r)
12344 {
12345         int level;
12346         uint32_t _level;
12347         TALLOC_CTX *_mem_save_neighbours_0;
12348         TALLOC_CTX *_mem_save_cursors_0;
12349         TALLOC_CTX *_mem_save_objmetadata_0;
12350         TALLOC_CTX *_mem_save_connectfailures_0;
12351         TALLOC_CTX *_mem_save_linkfailures_0;
12352         TALLOC_CTX *_mem_save_pendingops_0;
12353         TALLOC_CTX *_mem_save_attrvalmetadata_0;
12354         TALLOC_CTX *_mem_save_cursors2_0;
12355         TALLOC_CTX *_mem_save_cursors3_0;
12356         TALLOC_CTX *_mem_save_objmetadata2_0;
12357         TALLOC_CTX *_mem_save_attrvalmetadata2_0;
12358         TALLOC_CTX *_mem_save_neighbours02_0;
12359         TALLOC_CTX *_mem_save_connections04_0;
12360         TALLOC_CTX *_mem_save_cursors05_0;
12361         TALLOC_CTX *_mem_save_i06_0;
12362         level = ndr_pull_get_switch_value(ndr, r);
12363         if (ndr_flags & NDR_SCALARS) {
12364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12365                 if (_level != level) {
12366                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12367                 }
12368                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12369                 switch (level) {
12370                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12371                                 uint32_t _ptr_neighbours;
12372                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
12373                                 if (_ptr_neighbours) {
12374                                         NDR_PULL_ALLOC(ndr, r->neighbours);
12375                                 } else {
12376                                         r->neighbours = NULL;
12377                                 }
12378                         break; }
12379
12380                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12381                                 uint32_t _ptr_cursors;
12382                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
12383                                 if (_ptr_cursors) {
12384                                         NDR_PULL_ALLOC(ndr, r->cursors);
12385                                 } else {
12386                                         r->cursors = NULL;
12387                                 }
12388                         break; }
12389
12390                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12391                                 uint32_t _ptr_objmetadata;
12392                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
12393                                 if (_ptr_objmetadata) {
12394                                         NDR_PULL_ALLOC(ndr, r->objmetadata);
12395                                 } else {
12396                                         r->objmetadata = NULL;
12397                                 }
12398                         break; }
12399
12400                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12401                                 uint32_t _ptr_connectfailures;
12402                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
12403                                 if (_ptr_connectfailures) {
12404                                         NDR_PULL_ALLOC(ndr, r->connectfailures);
12405                                 } else {
12406                                         r->connectfailures = NULL;
12407                                 }
12408                         break; }
12409
12410                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12411                                 uint32_t _ptr_linkfailures;
12412                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
12413                                 if (_ptr_linkfailures) {
12414                                         NDR_PULL_ALLOC(ndr, r->linkfailures);
12415                                 } else {
12416                                         r->linkfailures = NULL;
12417                                 }
12418                         break; }
12419
12420                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12421                                 uint32_t _ptr_pendingops;
12422                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
12423                                 if (_ptr_pendingops) {
12424                                         NDR_PULL_ALLOC(ndr, r->pendingops);
12425                                 } else {
12426                                         r->pendingops = NULL;
12427                                 }
12428                         break; }
12429
12430                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12431                                 uint32_t _ptr_attrvalmetadata;
12432                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
12433                                 if (_ptr_attrvalmetadata) {
12434                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
12435                                 } else {
12436                                         r->attrvalmetadata = NULL;
12437                                 }
12438                         break; }
12439
12440                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12441                                 uint32_t _ptr_cursors2;
12442                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
12443                                 if (_ptr_cursors2) {
12444                                         NDR_PULL_ALLOC(ndr, r->cursors2);
12445                                 } else {
12446                                         r->cursors2 = NULL;
12447                                 }
12448                         break; }
12449
12450                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12451                                 uint32_t _ptr_cursors3;
12452                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
12453                                 if (_ptr_cursors3) {
12454                                         NDR_PULL_ALLOC(ndr, r->cursors3);
12455                                 } else {
12456                                         r->cursors3 = NULL;
12457                                 }
12458                         break; }
12459
12460                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12461                                 uint32_t _ptr_objmetadata2;
12462                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
12463                                 if (_ptr_objmetadata2) {
12464                                         NDR_PULL_ALLOC(ndr, r->objmetadata2);
12465                                 } else {
12466                                         r->objmetadata2 = NULL;
12467                                 }
12468                         break; }
12469
12470                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12471                                 uint32_t _ptr_attrvalmetadata2;
12472                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
12473                                 if (_ptr_attrvalmetadata2) {
12474                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
12475                                 } else {
12476                                         r->attrvalmetadata2 = NULL;
12477                                 }
12478                         break; }
12479
12480                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
12481                                 uint32_t _ptr_neighbours02;
12482                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours02));
12483                                 if (_ptr_neighbours02) {
12484                                         NDR_PULL_ALLOC(ndr, r->neighbours02);
12485                                 } else {
12486                                         r->neighbours02 = NULL;
12487                                 }
12488                         break; }
12489
12490                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
12491                                 uint32_t _ptr_connections04;
12492                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connections04));
12493                                 if (_ptr_connections04) {
12494                                         NDR_PULL_ALLOC(ndr, r->connections04);
12495                                 } else {
12496                                         r->connections04 = NULL;
12497                                 }
12498                         break; }
12499
12500                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
12501                                 uint32_t _ptr_cursors05;
12502                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors05));
12503                                 if (_ptr_cursors05) {
12504                                         NDR_PULL_ALLOC(ndr, r->cursors05);
12505                                 } else {
12506                                         r->cursors05 = NULL;
12507                                 }
12508                         break; }
12509
12510                         case DRSUAPI_DS_REPLICA_INFO_06: {
12511                                 uint32_t _ptr_i06;
12512                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_i06));
12513                                 if (_ptr_i06) {
12514                                         NDR_PULL_ALLOC(ndr, r->i06);
12515                                 } else {
12516                                         r->i06 = NULL;
12517                                 }
12518                         break; }
12519
12520                         default:
12521                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12522                 }
12523         }
12524         if (ndr_flags & NDR_BUFFERS) {
12525                 switch (level) {
12526                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12527                                 if (r->neighbours) {
12528                                         _mem_save_neighbours_0 = NDR_PULL_GET_MEM_CTX(ndr);
12529                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours, 0);
12530                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12531                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours_0, 0);
12532                                 }
12533                         break;
12534
12535                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12536                                 if (r->cursors) {
12537                                         _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
12538                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
12539                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12540                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
12541                                 }
12542                         break;
12543
12544                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12545                                 if (r->objmetadata) {
12546                                         _mem_save_objmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12547                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata, 0);
12548                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12549                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata_0, 0);
12550                                 }
12551                         break;
12552
12553                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12554                                 if (r->connectfailures) {
12555                                         _mem_save_connectfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12556                                         NDR_PULL_SET_MEM_CTX(ndr, r->connectfailures, 0);
12557                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12558                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connectfailures_0, 0);
12559                                 }
12560                         break;
12561
12562                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12563                                 if (r->linkfailures) {
12564                                         _mem_save_linkfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12565                                         NDR_PULL_SET_MEM_CTX(ndr, r->linkfailures, 0);
12566                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12567                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linkfailures_0, 0);
12568                                 }
12569                         break;
12570
12571                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12572                                 if (r->pendingops) {
12573                                         _mem_save_pendingops_0 = NDR_PULL_GET_MEM_CTX(ndr);
12574                                         NDR_PULL_SET_MEM_CTX(ndr, r->pendingops, 0);
12575                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12576                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pendingops_0, 0);
12577                                 }
12578                         break;
12579
12580                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12581                                 if (r->attrvalmetadata) {
12582                                         _mem_save_attrvalmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12583                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata, 0);
12584                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12585                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata_0, 0);
12586                                 }
12587                         break;
12588
12589                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12590                                 if (r->cursors2) {
12591                                         _mem_save_cursors2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12592                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors2, 0);
12593                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12594                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors2_0, 0);
12595                                 }
12596                         break;
12597
12598                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12599                                 if (r->cursors3) {
12600                                         _mem_save_cursors3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12601                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors3, 0);
12602                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12603                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors3_0, 0);
12604                                 }
12605                         break;
12606
12607                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12608                                 if (r->objmetadata2) {
12609                                         _mem_save_objmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12610                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata2, 0);
12611                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12612                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata2_0, 0);
12613                                 }
12614                         break;
12615
12616                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12617                                 if (r->attrvalmetadata2) {
12618                                         _mem_save_attrvalmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12619                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata2, 0);
12620                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12621                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata2_0, 0);
12622                                 }
12623                         break;
12624
12625                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12626                                 if (r->neighbours02) {
12627                                         _mem_save_neighbours02_0 = NDR_PULL_GET_MEM_CTX(ndr);
12628                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours02, 0);
12629                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12630                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours02_0, 0);
12631                                 }
12632                         break;
12633
12634                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12635                                 if (r->connections04) {
12636                                         _mem_save_connections04_0 = NDR_PULL_GET_MEM_CTX(ndr);
12637                                         NDR_PULL_SET_MEM_CTX(ndr, r->connections04, 0);
12638                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12639                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connections04_0, 0);
12640                                 }
12641                         break;
12642
12643                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12644                                 if (r->cursors05) {
12645                                         _mem_save_cursors05_0 = NDR_PULL_GET_MEM_CTX(ndr);
12646                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors05, 0);
12647                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12648                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors05_0, 0);
12649                                 }
12650                         break;
12651
12652                         case DRSUAPI_DS_REPLICA_INFO_06:
12653                                 if (r->i06) {
12654                                         _mem_save_i06_0 = NDR_PULL_GET_MEM_CTX(ndr);
12655                                         NDR_PULL_SET_MEM_CTX(ndr, r->i06, 0);
12656                                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12657                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_i06_0, 0);
12658                                 }
12659                         break;
12660
12661                         default:
12662                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12663                 }
12664         }
12665         return NDR_ERR_SUCCESS;
12666 }
12667
12668 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaInfo *r)
12669 {
12670         int level;
12671         level = ndr_print_get_switch_value(ndr, r);
12672         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaInfo");
12673         switch (level) {
12674                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12675                         ndr_print_ptr(ndr, "neighbours", r->neighbours);
12676                         ndr->depth++;
12677                         if (r->neighbours) {
12678                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours", r->neighbours);
12679                         }
12680                         ndr->depth--;
12681                 break;
12682
12683                 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12684                         ndr_print_ptr(ndr, "cursors", r->cursors);
12685                         ndr->depth++;
12686                         if (r->cursors) {
12687                                 ndr_print_drsuapi_DsReplicaCursorCtr(ndr, "cursors", r->cursors);
12688                         }
12689                         ndr->depth--;
12690                 break;
12691
12692                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12693                         ndr_print_ptr(ndr, "objmetadata", r->objmetadata);
12694                         ndr->depth++;
12695                         if (r->objmetadata) {
12696                                 ndr_print_drsuapi_DsReplicaObjMetaDataCtr(ndr, "objmetadata", r->objmetadata);
12697                         }
12698                         ndr->depth--;
12699                 break;
12700
12701                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12702                         ndr_print_ptr(ndr, "connectfailures", r->connectfailures);
12703                         ndr->depth++;
12704                         if (r->connectfailures) {
12705                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "connectfailures", r->connectfailures);
12706                         }
12707                         ndr->depth--;
12708                 break;
12709
12710                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12711                         ndr_print_ptr(ndr, "linkfailures", r->linkfailures);
12712                         ndr->depth++;
12713                         if (r->linkfailures) {
12714                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "linkfailures", r->linkfailures);
12715                         }
12716                         ndr->depth--;
12717                 break;
12718
12719                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12720                         ndr_print_ptr(ndr, "pendingops", r->pendingops);
12721                         ndr->depth++;
12722                         if (r->pendingops) {
12723                                 ndr_print_drsuapi_DsReplicaOpCtr(ndr, "pendingops", r->pendingops);
12724                         }
12725                         ndr->depth--;
12726                 break;
12727
12728                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12729                         ndr_print_ptr(ndr, "attrvalmetadata", r->attrvalmetadata);
12730                         ndr->depth++;
12731                         if (r->attrvalmetadata) {
12732                                 ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, "attrvalmetadata", r->attrvalmetadata);
12733                         }
12734                         ndr->depth--;
12735                 break;
12736
12737                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12738                         ndr_print_ptr(ndr, "cursors2", r->cursors2);
12739                         ndr->depth++;
12740                         if (r->cursors2) {
12741                                 ndr_print_drsuapi_DsReplicaCursor2Ctr(ndr, "cursors2", r->cursors2);
12742                         }
12743                         ndr->depth--;
12744                 break;
12745
12746                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12747                         ndr_print_ptr(ndr, "cursors3", r->cursors3);
12748                         ndr->depth++;
12749                         if (r->cursors3) {
12750                                 ndr_print_drsuapi_DsReplicaCursor3Ctr(ndr, "cursors3", r->cursors3);
12751                         }
12752                         ndr->depth--;
12753                 break;
12754
12755                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12756                         ndr_print_ptr(ndr, "objmetadata2", r->objmetadata2);
12757                         ndr->depth++;
12758                         if (r->objmetadata2) {
12759                                 ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(ndr, "objmetadata2", r->objmetadata2);
12760                         }
12761                         ndr->depth--;
12762                 break;
12763
12764                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12765                         ndr_print_ptr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12766                         ndr->depth++;
12767                         if (r->attrvalmetadata2) {
12768                                 ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12769                         }
12770                         ndr->depth--;
12771                 break;
12772
12773                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12774                         ndr_print_ptr(ndr, "neighbours02", r->neighbours02);
12775                         ndr->depth++;
12776                         if (r->neighbours02) {
12777                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours02", r->neighbours02);
12778                         }
12779                         ndr->depth--;
12780                 break;
12781
12782                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12783                         ndr_print_ptr(ndr, "connections04", r->connections04);
12784                         ndr->depth++;
12785                         if (r->connections04) {
12786                                 ndr_print_drsuapi_DsReplicaConnection04Ctr(ndr, "connections04", r->connections04);
12787                         }
12788                         ndr->depth--;
12789                 break;
12790
12791                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12792                         ndr_print_ptr(ndr, "cursors05", r->cursors05);
12793                         ndr->depth++;
12794                         if (r->cursors05) {
12795                                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "cursors05", r->cursors05);
12796                         }
12797                         ndr->depth--;
12798                 break;
12799
12800                 case DRSUAPI_DS_REPLICA_INFO_06:
12801                         ndr_print_ptr(ndr, "i06", r->i06);
12802                         ndr->depth++;
12803                         if (r->i06) {
12804                                 ndr_print_drsuapi_DsReplica06Ctr(ndr, "i06", r->i06);
12805                         }
12806                         ndr->depth--;
12807                 break;
12808
12809                 default:
12810                         ndr_print_bad_level(ndr, name, level);
12811         }
12812 }
12813
12814 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Ctr *r)
12815 {
12816         if (ndr_flags & NDR_SCALARS) {
12817                 int level = ndr_push_get_switch_value(ndr, r);
12818                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12819                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12820                 switch (level) {
12821                         case 1: {
12822                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12823                         break; }
12824
12825                         default:
12826                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12827                 }
12828         }
12829         if (ndr_flags & NDR_BUFFERS) {
12830                 int level = ndr_push_get_switch_value(ndr, r);
12831                 switch (level) {
12832                         case 1:
12833                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12834                         break;
12835
12836                         default:
12837                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12838                 }
12839         }
12840         return NDR_ERR_SUCCESS;
12841 }
12842
12843 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Ctr *r)
12844 {
12845         int level;
12846         int32_t _level;
12847         level = ndr_pull_get_switch_value(ndr, r);
12848         if (ndr_flags & NDR_SCALARS) {
12849                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12850                 if (_level != level) {
12851                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12852                 }
12853                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12854                 switch (level) {
12855                         case 1: {
12856                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12857                         break; }
12858
12859                         default:
12860                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12861                 }
12862         }
12863         if (ndr_flags & NDR_BUFFERS) {
12864                 switch (level) {
12865                         case 1:
12866                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12867                         break;
12868
12869                         default:
12870                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12871                 }
12872         }
12873         return NDR_ERR_SUCCESS;
12874 }
12875
12876 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Ctr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Ctr *r)
12877 {
12878         int level;
12879         level = ndr_print_get_switch_value(ndr, r);
12880         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Ctr");
12881         switch (level) {
12882                 case 1:
12883                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
12884                 break;
12885
12886                 default:
12887                         ndr_print_bad_level(ndr, name, level);
12888         }
12889 }
12890
12891 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMemberships2Request1 *r)
12892 {
12893         uint32_t cntr_req_array_1;
12894         if (ndr_flags & NDR_SCALARS) {
12895                 NDR_CHECK(ndr_push_align(ndr, 5));
12896                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12897                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
12898                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12899         }
12900         if (ndr_flags & NDR_BUFFERS) {
12901                 if (r->req_array) {
12902                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
12903                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12904                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
12905                         }
12906                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12907                                 if (r->req_array[cntr_req_array_1]) {
12908                                         NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12909                                 }
12910                         }
12911                 }
12912         }
12913         return NDR_ERR_SUCCESS;
12914 }
12915
12916 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
12917 {
12918         uint32_t _ptr_req_array;
12919         uint32_t cntr_req_array_1;
12920         TALLOC_CTX *_mem_save_req_array_0;
12921         TALLOC_CTX *_mem_save_req_array_1;
12922         TALLOC_CTX *_mem_save_req_array_2;
12923         if (ndr_flags & NDR_SCALARS) {
12924                 NDR_CHECK(ndr_pull_align(ndr, 5));
12925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12926                 if (r->num_req < 1 || r->num_req > 10000) {
12927                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12928                 }
12929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12930                 if (_ptr_req_array) {
12931                         NDR_PULL_ALLOC(ndr, r->req_array);
12932                 } else {
12933                         r->req_array = NULL;
12934                 }
12935                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12936         }
12937         if (ndr_flags & NDR_BUFFERS) {
12938                 if (r->req_array) {
12939                         _mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12940                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12941                         NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
12942                         NDR_PULL_ALLOC_N(ndr, r->req_array, ndr_get_array_size(ndr, &r->req_array));
12943                         _mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12944                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12945                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12946                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12947                                 if (_ptr_req_array) {
12948                                         NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
12949                                 } else {
12950                                         r->req_array[cntr_req_array_1] = NULL;
12951                                 }
12952                         }
12953                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12954                                 if (r->req_array[cntr_req_array_1]) {
12955                                         _mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
12956                                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
12957                                         NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12958                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_2, 0);
12959                                 }
12960                         }
12961                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_1, 0);
12962                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_0, 0);
12963                 }
12964                 if (r->req_array) {
12965                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->req_array, r->num_req));
12966                 }
12967         }
12968         return NDR_ERR_SUCCESS;
12969 }
12970
12971 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMemberships2Request1 *r)
12972 {
12973         uint32_t cntr_req_array_1;
12974         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2Request1");
12975         ndr->depth++;
12976         ndr_print_uint32(ndr, "num_req", r->num_req);
12977         ndr_print_ptr(ndr, "req_array", r->req_array);
12978         ndr->depth++;
12979         if (r->req_array) {
12980                 ndr->print(ndr, "%s: ARRAY(%d)", "req_array", (int)r->num_req);
12981                 ndr->depth++;
12982                 for (cntr_req_array_1=0;cntr_req_array_1<r->num_req;cntr_req_array_1++) {
12983                         char *idx_1=NULL;
12984                         if (asprintf(&idx_1, "[%d]", cntr_req_array_1) != -1) {
12985                                 ndr_print_ptr(ndr, "req_array", r->req_array[cntr_req_array_1]);
12986                                 ndr->depth++;
12987                                 if (r->req_array[cntr_req_array_1]) {
12988                                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req_array", r->req_array[cntr_req_array_1]);
12989                                 }
12990                                 ndr->depth--;
12991                                 free(idx_1);
12992                         }
12993                 }
12994                 ndr->depth--;
12995         }
12996         ndr->depth--;
12997         ndr->depth--;
12998 }
12999
13000 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Request *r)
13001 {
13002         if (ndr_flags & NDR_SCALARS) {
13003                 int level = ndr_push_get_switch_value(ndr, r);
13004                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13005                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13006                 switch (level) {
13007                         case 1: {
13008                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
13009                         break; }
13010
13011                         default:
13012                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13013                 }
13014         }
13015         if (ndr_flags & NDR_BUFFERS) {
13016                 int level = ndr_push_get_switch_value(ndr, r);
13017                 switch (level) {
13018                         case 1:
13019                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
13020                         break;
13021
13022                         default:
13023                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13024                 }
13025         }
13026         return NDR_ERR_SUCCESS;
13027 }
13028
13029 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Request *r)
13030 {
13031         int level;
13032         int32_t _level;
13033         level = ndr_pull_get_switch_value(ndr, r);
13034         if (ndr_flags & NDR_SCALARS) {
13035                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13036                 if (_level != level) {
13037                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13038                 }
13039                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13040                 switch (level) {
13041                         case 1: {
13042                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
13043                         break; }
13044
13045                         default:
13046                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13047                 }
13048         }
13049         if (ndr_flags & NDR_BUFFERS) {
13050                 switch (level) {
13051                         case 1:
13052                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
13053                         break;
13054
13055                         default:
13056                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13057                 }
13058         }
13059         return NDR_ERR_SUCCESS;
13060 }
13061
13062 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Request *r)
13063 {
13064         int level;
13065         level = ndr_print_get_switch_value(ndr, r);
13066         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Request");
13067         switch (level) {
13068                 case 1:
13069                         ndr_print_drsuapi_DsGetMemberships2Request1(ndr, "req1", &r->req1);
13070                 break;
13071
13072                 default:
13073                         ndr_print_bad_level(ndr, name, level);
13074         }
13075 }
13076
13077 static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsSiteCostInfo *r)
13078 {
13079         if (ndr_flags & NDR_SCALARS) {
13080                 NDR_CHECK(ndr_push_align(ndr, 4));
13081                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
13082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
13083                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
13084         }
13085         if (ndr_flags & NDR_BUFFERS) {
13086         }
13087         return NDR_ERR_SUCCESS;
13088 }
13089
13090 static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsSiteCostInfo *r)
13091 {
13092         if (ndr_flags & NDR_SCALARS) {
13093                 NDR_CHECK(ndr_pull_align(ndr, 4));
13094                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
13095                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
13096                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
13097         }
13098         if (ndr_flags & NDR_BUFFERS) {
13099         }
13100         return NDR_ERR_SUCCESS;
13101 }
13102
13103 _PUBLIC_ void ndr_print_drsuapi_DsSiteCostInfo(struct ndr_print *ndr, const char *name, const struct drsuapi_DsSiteCostInfo *r)
13104 {
13105         ndr_print_struct(ndr, name, "drsuapi_DsSiteCostInfo");
13106         ndr->depth++;
13107         ndr_print_WERROR(ndr, "error_code", r->error_code);
13108         ndr_print_uint32(ndr, "site_cost", r->site_cost);
13109         ndr->depth--;
13110 }
13111
13112 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostCtr1 *r)
13113 {
13114         uint32_t cntr_info_1;
13115         if (ndr_flags & NDR_SCALARS) {
13116                 NDR_CHECK(ndr_push_align(ndr, 5));
13117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
13118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
13119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
13120                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13121         }
13122         if (ndr_flags & NDR_BUFFERS) {
13123                 if (r->info) {
13124                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_info));
13125                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
13126                                 NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
13127                         }
13128                 }
13129         }
13130         return NDR_ERR_SUCCESS;
13131 }
13132
13133 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
13134 {
13135         uint32_t _ptr_info;
13136         uint32_t cntr_info_1;
13137         TALLOC_CTX *_mem_save_info_0;
13138         TALLOC_CTX *_mem_save_info_1;
13139         if (ndr_flags & NDR_SCALARS) {
13140                 NDR_CHECK(ndr_pull_align(ndr, 5));
13141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
13142                 if (r->num_info > 10000) {
13143                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
13144                 }
13145                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
13146                 if (_ptr_info) {
13147                         NDR_PULL_ALLOC(ndr, r->info);
13148                 } else {
13149                         r->info = NULL;
13150                 }
13151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
13152                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13153         }
13154         if (ndr_flags & NDR_BUFFERS) {
13155                 if (r->info) {
13156                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13157                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
13158                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
13159                         NDR_PULL_ALLOC_N(ndr, r->info, ndr_get_array_size(ndr, &r->info));
13160                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
13161                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
13162                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
13163                                 NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
13164                         }
13165                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
13166                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
13167                 }
13168                 if (r->info) {
13169                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info, r->num_info));
13170                 }
13171         }
13172         return NDR_ERR_SUCCESS;
13173 }
13174
13175 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostCtr1 *r)
13176 {
13177         uint32_t cntr_info_1;
13178         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostCtr1");
13179         ndr->depth++;
13180         ndr_print_uint32(ndr, "num_info", r->num_info);
13181         ndr_print_ptr(ndr, "info", r->info);
13182         ndr->depth++;
13183         if (r->info) {
13184                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->num_info);
13185                 ndr->depth++;
13186                 for (cntr_info_1=0;cntr_info_1<r->num_info;cntr_info_1++) {
13187                         char *idx_1=NULL;
13188                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
13189                                 ndr_print_drsuapi_DsSiteCostInfo(ndr, "info", &r->info[cntr_info_1]);
13190                                 free(idx_1);
13191                         }
13192                 }
13193                 ndr->depth--;
13194         }
13195         ndr->depth--;
13196         ndr_print_uint32(ndr, "unknown", r->unknown);
13197         ndr->depth--;
13198 }
13199
13200 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostCtr *r)
13201 {
13202         if (ndr_flags & NDR_SCALARS) {
13203                 int level = ndr_push_get_switch_value(ndr, r);
13204                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13205                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13206                 switch (level) {
13207                         case 1: {
13208                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
13209                         break; }
13210
13211                         default:
13212                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13213                 }
13214         }
13215         if (ndr_flags & NDR_BUFFERS) {
13216                 int level = ndr_push_get_switch_value(ndr, r);
13217                 switch (level) {
13218                         case 1:
13219                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
13220                         break;
13221
13222                         default:
13223                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13224                 }
13225         }
13226         return NDR_ERR_SUCCESS;
13227 }
13228
13229 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostCtr *r)
13230 {
13231         int level;
13232         int32_t _level;
13233         level = ndr_pull_get_switch_value(ndr, r);
13234         if (ndr_flags & NDR_SCALARS) {
13235                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13236                 if (_level != level) {
13237                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13238                 }
13239                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13240                 switch (level) {
13241                         case 1: {
13242                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
13243                         break; }
13244
13245                         default:
13246                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13247                 }
13248         }
13249         if (ndr_flags & NDR_BUFFERS) {
13250                 switch (level) {
13251                         case 1:
13252                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
13253                         break;
13254
13255                         default:
13256                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13257                 }
13258         }
13259         return NDR_ERR_SUCCESS;
13260 }
13261
13262 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostCtr *r)
13263 {
13264         int level;
13265         level = ndr_print_get_switch_value(ndr, r);
13266         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostCtr");
13267         switch (level) {
13268                 case 1:
13269                         ndr_print_drsuapi_QuerySitesByCostCtr1(ndr, "ctr1", &r->ctr1);
13270                 break;
13271
13272                 default:
13273                         ndr_print_bad_level(ndr, name, level);
13274         }
13275 }
13276
13277 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostRequest1 *r)
13278 {
13279         uint32_t cntr_site_to_1;
13280         if (ndr_flags & NDR_SCALARS) {
13281                 NDR_CHECK(ndr_push_align(ndr, 5));
13282                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
13283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
13284                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
13285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13286                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13287         }
13288         if (ndr_flags & NDR_BUFFERS) {
13289                 if (r->site_from) {
13290                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13291                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13292                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13293                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13294                 }
13295                 if (r->site_to) {
13296                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
13297                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13298                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
13299                         }
13300                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13301                                 if (r->site_to[cntr_site_to_1]) {
13302                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13303                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13304                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13305                                         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));
13306                                 }
13307                         }
13308                 }
13309         }
13310         return NDR_ERR_SUCCESS;
13311 }
13312
13313 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
13314 {
13315         uint32_t _ptr_site_from;
13316         TALLOC_CTX *_mem_save_site_from_0;
13317         uint32_t _ptr_site_to;
13318         uint32_t cntr_site_to_1;
13319         TALLOC_CTX *_mem_save_site_to_0;
13320         TALLOC_CTX *_mem_save_site_to_1;
13321         TALLOC_CTX *_mem_save_site_to_2;
13322         if (ndr_flags & NDR_SCALARS) {
13323                 NDR_CHECK(ndr_pull_align(ndr, 5));
13324                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
13325                 if (_ptr_site_from) {
13326                         NDR_PULL_ALLOC(ndr, r->site_from);
13327                 } else {
13328                         r->site_from = NULL;
13329                 }
13330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
13331                 if (r->num_req < 1 || r->num_req > 10000) {
13332                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
13333                 }
13334                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13335                 if (_ptr_site_to) {
13336                         NDR_PULL_ALLOC(ndr, r->site_to);
13337                 } else {
13338                         r->site_to = NULL;
13339                 }
13340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13341                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13342         }
13343         if (ndr_flags & NDR_BUFFERS) {
13344                 if (r->site_from) {
13345                         _mem_save_site_from_0 = NDR_PULL_GET_MEM_CTX(ndr);
13346                         NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
13347                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
13348                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
13349                         if (ndr_get_array_length(ndr, &r->site_from) > ndr_get_array_size(ndr, &r->site_from)) {
13350                                 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));
13351                         }
13352                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t)));
13353                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t), CH_UTF16));
13354                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
13355                 }
13356                 if (r->site_to) {
13357                         _mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
13358                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13359                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
13360                         NDR_PULL_ALLOC_N(ndr, r->site_to, ndr_get_array_size(ndr, &r->site_to));
13361                         _mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
13362                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13363                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13364                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13365                                 if (_ptr_site_to) {
13366                                         NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
13367                                 } else {
13368                                         r->site_to[cntr_site_to_1] = NULL;
13369                                 }
13370                         }
13371                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13372                                 if (r->site_to[cntr_site_to_1]) {
13373                                         _mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
13374                                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
13375                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
13376                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
13377                                         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])) {
13378                                                 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]));
13379                                         }
13380                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t)));
13381                                         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));
13382                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
13383                                 }
13384                         }
13385                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_1, 0);
13386                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_0, 0);
13387                 }
13388                 if (r->site_to) {
13389                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->site_to, r->num_req));
13390                 }
13391         }
13392         return NDR_ERR_SUCCESS;
13393 }
13394
13395 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostRequest1 *r)
13396 {
13397         uint32_t cntr_site_to_1;
13398         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostRequest1");
13399         ndr->depth++;
13400         ndr_print_ptr(ndr, "site_from", r->site_from);
13401         ndr->depth++;
13402         if (r->site_from) {
13403                 ndr_print_string(ndr, "site_from", r->site_from);
13404         }
13405         ndr->depth--;
13406         ndr_print_uint32(ndr, "num_req", r->num_req);
13407         ndr_print_ptr(ndr, "site_to", r->site_to);
13408         ndr->depth++;
13409         if (r->site_to) {
13410                 ndr->print(ndr, "%s: ARRAY(%d)", "site_to", (int)r->num_req);
13411                 ndr->depth++;
13412                 for (cntr_site_to_1=0;cntr_site_to_1<r->num_req;cntr_site_to_1++) {
13413                         char *idx_1=NULL;
13414                         if (asprintf(&idx_1, "[%d]", cntr_site_to_1) != -1) {
13415                                 ndr_print_ptr(ndr, "site_to", r->site_to[cntr_site_to_1]);
13416                                 ndr->depth++;
13417                                 if (r->site_to[cntr_site_to_1]) {
13418                                         ndr_print_string(ndr, "site_to", r->site_to[cntr_site_to_1]);
13419                                 }
13420                                 ndr->depth--;
13421                                 free(idx_1);
13422                         }
13423                 }
13424                 ndr->depth--;
13425         }
13426         ndr->depth--;
13427         ndr_print_uint32(ndr, "flags", r->flags);
13428         ndr->depth--;
13429 }
13430
13431 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostRequest *r)
13432 {
13433         if (ndr_flags & NDR_SCALARS) {
13434                 int level = ndr_push_get_switch_value(ndr, r);
13435                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13436                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13437                 switch (level) {
13438                         case 1: {
13439                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13440                         break; }
13441
13442                         default:
13443                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13444                 }
13445         }
13446         if (ndr_flags & NDR_BUFFERS) {
13447                 int level = ndr_push_get_switch_value(ndr, r);
13448                 switch (level) {
13449                         case 1:
13450                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13451                         break;
13452
13453                         default:
13454                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13455                 }
13456         }
13457         return NDR_ERR_SUCCESS;
13458 }
13459
13460 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostRequest *r)
13461 {
13462         int level;
13463         int32_t _level;
13464         level = ndr_pull_get_switch_value(ndr, r);
13465         if (ndr_flags & NDR_SCALARS) {
13466                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13467                 if (_level != level) {
13468                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13469                 }
13470                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13471                 switch (level) {
13472                         case 1: {
13473                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13474                         break; }
13475
13476                         default:
13477                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13478                 }
13479         }
13480         if (ndr_flags & NDR_BUFFERS) {
13481                 switch (level) {
13482                         case 1:
13483                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13484                         break;
13485
13486                         default:
13487                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13488                 }
13489         }
13490         return NDR_ERR_SUCCESS;
13491 }
13492
13493 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostRequest *r)
13494 {
13495         int level;
13496         level = ndr_print_get_switch_value(ndr, r);
13497         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostRequest");
13498         switch (level) {
13499                 case 1:
13500                         ndr_print_drsuapi_QuerySitesByCostRequest1(ndr, "req1", &r->req1);
13501                 break;
13502
13503                 default:
13504                         ndr_print_bad_level(ndr, name, level);
13505         }
13506 }
13507
13508 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsBind(struct ndr_push *ndr, int flags, const struct drsuapi_DsBind *r)
13509 {
13510         if (flags & NDR_IN) {
13511                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_guid));
13512                 if (r->in.bind_guid) {
13513                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13514                 }
13515                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_info));
13516                 if (r->in.bind_info) {
13517                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13518                 }
13519         }
13520         if (flags & NDR_OUT) {
13521                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.bind_info));
13522                 if (r->out.bind_info) {
13523                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13524                 }
13525                 if (r->out.bind_handle == NULL) {
13526                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13527                 }
13528                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13529                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13530         }
13531         return NDR_ERR_SUCCESS;
13532 }
13533
13534 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsBind(struct ndr_pull *ndr, int flags, struct drsuapi_DsBind *r)
13535 {
13536         uint32_t _ptr_bind_guid;
13537         uint32_t _ptr_bind_info;
13538         TALLOC_CTX *_mem_save_bind_guid_0;
13539         TALLOC_CTX *_mem_save_bind_info_0;
13540         TALLOC_CTX *_mem_save_bind_handle_0;
13541         if (flags & NDR_IN) {
13542                 ZERO_STRUCT(r->out);
13543
13544                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_guid));
13545                 if (_ptr_bind_guid) {
13546                         NDR_PULL_ALLOC(ndr, r->in.bind_guid);
13547                 } else {
13548                         r->in.bind_guid = NULL;
13549                 }
13550                 if (r->in.bind_guid) {
13551                         _mem_save_bind_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
13552                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_guid, 0);
13553                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13554                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_guid_0, 0);
13555                 }
13556                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13557                 if (_ptr_bind_info) {
13558                         NDR_PULL_ALLOC(ndr, r->in.bind_info);
13559                 } else {
13560                         r->in.bind_info = NULL;
13561                 }
13562                 if (r->in.bind_info) {
13563                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13564                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_info, 0);
13565                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13566                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13567                 }
13568                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13569                 ZERO_STRUCTP(r->out.bind_handle);
13570         }
13571         if (flags & NDR_OUT) {
13572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13573                 if (_ptr_bind_info) {
13574                         NDR_PULL_ALLOC(ndr, r->out.bind_info);
13575                 } else {
13576                         r->out.bind_info = NULL;
13577                 }
13578                 if (r->out.bind_info) {
13579                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13580                         NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_info, 0);
13581                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13582                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13583                 }
13584                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13585                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13586                 }
13587                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13588                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13589                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13590                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13591                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13592         }
13593         return NDR_ERR_SUCCESS;
13594 }
13595
13596 _PUBLIC_ void ndr_print_drsuapi_DsBind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsBind *r)
13597 {
13598         ndr_print_struct(ndr, name, "drsuapi_DsBind");
13599         ndr->depth++;
13600         if (flags & NDR_SET_VALUES) {
13601                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13602         }
13603         if (flags & NDR_IN) {
13604                 ndr_print_struct(ndr, "in", "drsuapi_DsBind");
13605                 ndr->depth++;
13606                 ndr_print_ptr(ndr, "bind_guid", r->in.bind_guid);
13607                 ndr->depth++;
13608                 if (r->in.bind_guid) {
13609                         ndr_print_GUID(ndr, "bind_guid", r->in.bind_guid);
13610                 }
13611                 ndr->depth--;
13612                 ndr_print_ptr(ndr, "bind_info", r->in.bind_info);
13613                 ndr->depth++;
13614                 if (r->in.bind_info) {
13615                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->in.bind_info);
13616                 }
13617                 ndr->depth--;
13618                 ndr->depth--;
13619         }
13620         if (flags & NDR_OUT) {
13621                 ndr_print_struct(ndr, "out", "drsuapi_DsBind");
13622                 ndr->depth++;
13623                 ndr_print_ptr(ndr, "bind_info", r->out.bind_info);
13624                 ndr->depth++;
13625                 if (r->out.bind_info) {
13626                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->out.bind_info);
13627                 }
13628                 ndr->depth--;
13629                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13630                 ndr->depth++;
13631                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13632                 ndr->depth--;
13633                 ndr_print_WERROR(ndr, "result", r->out.result);
13634                 ndr->depth--;
13635         }
13636         ndr->depth--;
13637 }
13638
13639 static enum ndr_err_code ndr_push_drsuapi_DsUnbind(struct ndr_push *ndr, int flags, const struct drsuapi_DsUnbind *r)
13640 {
13641         if (flags & NDR_IN) {
13642                 if (r->in.bind_handle == NULL) {
13643                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13644                 }
13645                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13646         }
13647         if (flags & NDR_OUT) {
13648                 if (r->out.bind_handle == NULL) {
13649                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13650                 }
13651                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13652                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13653         }
13654         return NDR_ERR_SUCCESS;
13655 }
13656
13657 static enum ndr_err_code ndr_pull_drsuapi_DsUnbind(struct ndr_pull *ndr, int flags, struct drsuapi_DsUnbind *r)
13658 {
13659         TALLOC_CTX *_mem_save_bind_handle_0;
13660         if (flags & NDR_IN) {
13661                 ZERO_STRUCT(r->out);
13662
13663                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13664                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13665                 }
13666                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13667                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13668                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13669                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13670                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13671                 *r->out.bind_handle = *r->in.bind_handle;
13672         }
13673         if (flags & NDR_OUT) {
13674                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13675                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13676                 }
13677                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13678                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13679                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13680                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13681                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13682         }
13683         return NDR_ERR_SUCCESS;
13684 }
13685
13686 _PUBLIC_ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsUnbind *r)
13687 {
13688         ndr_print_struct(ndr, name, "drsuapi_DsUnbind");
13689         ndr->depth++;
13690         if (flags & NDR_SET_VALUES) {
13691                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13692         }
13693         if (flags & NDR_IN) {
13694                 ndr_print_struct(ndr, "in", "drsuapi_DsUnbind");
13695                 ndr->depth++;
13696                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13697                 ndr->depth++;
13698                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13699                 ndr->depth--;
13700                 ndr->depth--;
13701         }
13702         if (flags & NDR_OUT) {
13703                 ndr_print_struct(ndr, "out", "drsuapi_DsUnbind");
13704                 ndr->depth++;
13705                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13706                 ndr->depth++;
13707                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13708                 ndr->depth--;
13709                 ndr_print_WERROR(ndr, "result", r->out.result);
13710                 ndr->depth--;
13711         }
13712         ndr->depth--;
13713 }
13714
13715 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSync(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaSync *r)
13716 {
13717         if (flags & NDR_IN) {
13718                 if (r->in.bind_handle == NULL) {
13719                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13720                 }
13721                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13722                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13723                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13724                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13725         }
13726         if (flags & NDR_OUT) {
13727                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13728         }
13729         return NDR_ERR_SUCCESS;
13730 }
13731
13732 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSync(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaSync *r)
13733 {
13734         TALLOC_CTX *_mem_save_bind_handle_0;
13735         if (flags & NDR_IN) {
13736                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13737                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13738                 }
13739                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13740                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13741                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13742                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13743                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13744                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13745                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13746         }
13747         if (flags & NDR_OUT) {
13748                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13749         }
13750         return NDR_ERR_SUCCESS;
13751 }
13752
13753 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r)
13754 {
13755         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSync");
13756         ndr->depth++;
13757         if (flags & NDR_SET_VALUES) {
13758                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13759         }
13760         if (flags & NDR_IN) {
13761                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaSync");
13762                 ndr->depth++;
13763                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13764                 ndr->depth++;
13765                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13766                 ndr->depth--;
13767                 ndr_print_int32(ndr, "level", r->in.level);
13768                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13769                 ndr_print_drsuapi_DsReplicaSyncRequest(ndr, "req", &r->in.req);
13770                 ndr->depth--;
13771         }
13772         if (flags & NDR_OUT) {
13773                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaSync");
13774                 ndr->depth++;
13775                 ndr_print_WERROR(ndr, "result", r->out.result);
13776                 ndr->depth--;
13777         }
13778         ndr->depth--;
13779 }
13780
13781 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChanges(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNCChanges *r)
13782 {
13783         if (flags & NDR_IN) {
13784                 if (r->in.bind_handle == NULL) {
13785                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13786                 }
13787                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13788                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13789                 if (r->in.req == NULL) {
13790                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13791                 }
13792                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13793                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13794         }
13795         if (flags & NDR_OUT) {
13796                 if (r->out.level_out == NULL) {
13797                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13798                 }
13799                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13800                 if (r->out.ctr == NULL) {
13801                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13802                 }
13803                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13804                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13805                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13806         }
13807         return NDR_ERR_SUCCESS;
13808 }
13809
13810 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChanges(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNCChanges *r)
13811 {
13812         TALLOC_CTX *_mem_save_bind_handle_0;
13813         TALLOC_CTX *_mem_save_req_0;
13814         TALLOC_CTX *_mem_save_level_out_0;
13815         TALLOC_CTX *_mem_save_ctr_0;
13816         if (flags & NDR_IN) {
13817                 ZERO_STRUCT(r->out);
13818
13819                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13820                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13821                 }
13822                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13823                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13824                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13825                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13826                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13827                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13828                         NDR_PULL_ALLOC(ndr, r->in.req);
13829                 }
13830                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13831                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13832                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13833                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13834                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13835                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13836                 ZERO_STRUCTP(r->out.level_out);
13837                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13838                 ZERO_STRUCTP(r->out.ctr);
13839         }
13840         if (flags & NDR_OUT) {
13841                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13842                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13843                 }
13844                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13845                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13846                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13847                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13848                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13849                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13850                 }
13851                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13852                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13853                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13854                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13855                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13856                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13857         }
13858         return NDR_ERR_SUCCESS;
13859 }
13860
13861 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r)
13862 {
13863         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChanges");
13864         ndr->depth++;
13865         if (flags & NDR_SET_VALUES) {
13866                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13867         }
13868         if (flags & NDR_IN) {
13869                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNCChanges");
13870                 ndr->depth++;
13871                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13872                 ndr->depth++;
13873                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13874                 ndr->depth--;
13875                 ndr_print_int32(ndr, "level", r->in.level);
13876                 ndr_print_ptr(ndr, "req", r->in.req);
13877                 ndr->depth++;
13878                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13879                 ndr_print_drsuapi_DsGetNCChangesRequest(ndr, "req", r->in.req);
13880                 ndr->depth--;
13881                 ndr->depth--;
13882         }
13883         if (flags & NDR_OUT) {
13884                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNCChanges");
13885                 ndr->depth++;
13886                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13887                 ndr->depth++;
13888                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13889                 ndr->depth--;
13890                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13891                 ndr->depth++;
13892                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13893                 ndr_print_drsuapi_DsGetNCChangesCtr(ndr, "ctr", r->out.ctr);
13894                 ndr->depth--;
13895                 ndr_print_WERROR(ndr, "result", r->out.result);
13896                 ndr->depth--;
13897         }
13898         ndr->depth--;
13899 }
13900
13901 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefs(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13902 {
13903         if (flags & NDR_IN) {
13904                 if (r->in.bind_handle == NULL) {
13905                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13906                 }
13907                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13908                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13909                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13910                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13911         }
13912         if (flags & NDR_OUT) {
13913                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13914         }
13915         return NDR_ERR_SUCCESS;
13916 }
13917
13918 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefs(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaUpdateRefs *r)
13919 {
13920         TALLOC_CTX *_mem_save_bind_handle_0;
13921         if (flags & NDR_IN) {
13922                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13923                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13924                 }
13925                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13926                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13927                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13928                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13929                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13930                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13931                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13932         }
13933         if (flags & NDR_OUT) {
13934                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13935         }
13936         return NDR_ERR_SUCCESS;
13937 }
13938
13939 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13940 {
13941         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefs");
13942         ndr->depth++;
13943         if (flags & NDR_SET_VALUES) {
13944                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13945         }
13946         if (flags & NDR_IN) {
13947                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaUpdateRefs");
13948                 ndr->depth++;
13949                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13950                 ndr->depth++;
13951                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13952                 ndr->depth--;
13953                 ndr_print_int32(ndr, "level", r->in.level);
13954                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13955                 ndr_print_drsuapi_DsReplicaUpdateRefsRequest(ndr, "req", &r->in.req);
13956                 ndr->depth--;
13957         }
13958         if (flags & NDR_OUT) {
13959                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaUpdateRefs");
13960                 ndr->depth++;
13961                 ndr_print_WERROR(ndr, "result", r->out.result);
13962                 ndr->depth--;
13963         }
13964         ndr->depth--;
13965 }
13966
13967 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAdd(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaAdd *r)
13968 {
13969         if (flags & NDR_IN) {
13970                 if (r->in.bind_handle == NULL) {
13971                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13972                 }
13973                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13974                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13975                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13976                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13977         }
13978         if (flags & NDR_OUT) {
13979                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13980         }
13981         return NDR_ERR_SUCCESS;
13982 }
13983
13984 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAdd(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaAdd *r)
13985 {
13986         TALLOC_CTX *_mem_save_bind_handle_0;
13987         if (flags & NDR_IN) {
13988                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13989                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13990                 }
13991                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13992                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13993                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13994                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13995                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13996                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13997                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13998         }
13999         if (flags & NDR_OUT) {
14000                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14001         }
14002         return NDR_ERR_SUCCESS;
14003 }
14004
14005 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r)
14006 {
14007         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAdd");
14008         ndr->depth++;
14009         if (flags & NDR_SET_VALUES) {
14010                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14011         }
14012         if (flags & NDR_IN) {
14013                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaAdd");
14014                 ndr->depth++;
14015                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14016                 ndr->depth++;
14017                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14018                 ndr->depth--;
14019                 ndr_print_int32(ndr, "level", r->in.level);
14020                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
14021                 ndr_print_drsuapi_DsReplicaAddRequest(ndr, "req", &r->in.req);
14022                 ndr->depth--;
14023         }
14024         if (flags & NDR_OUT) {
14025                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaAdd");
14026                 ndr->depth++;
14027                 ndr_print_WERROR(ndr, "result", r->out.result);
14028                 ndr->depth--;
14029         }
14030         ndr->depth--;
14031 }
14032
14033 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDel(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaDel *r)
14034 {
14035         if (flags & NDR_IN) {
14036                 if (r->in.bind_handle == NULL) {
14037                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14038                 }
14039                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14040                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14041                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
14042                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14043         }
14044         if (flags & NDR_OUT) {
14045                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14046         }
14047         return NDR_ERR_SUCCESS;
14048 }
14049
14050 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDel(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaDel *r)
14051 {
14052         TALLOC_CTX *_mem_save_bind_handle_0;
14053         if (flags & NDR_IN) {
14054                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14055                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14056                 }
14057                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14058                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14059                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14060                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14061                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14062                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
14063                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14064         }
14065         if (flags & NDR_OUT) {
14066                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14067         }
14068         return NDR_ERR_SUCCESS;
14069 }
14070
14071 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r)
14072 {
14073         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDel");
14074         ndr->depth++;
14075         if (flags & NDR_SET_VALUES) {
14076                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14077         }
14078         if (flags & NDR_IN) {
14079                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaDel");
14080                 ndr->depth++;
14081                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14082                 ndr->depth++;
14083                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14084                 ndr->depth--;
14085                 ndr_print_int32(ndr, "level", r->in.level);
14086                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
14087                 ndr_print_drsuapi_DsReplicaDelRequest(ndr, "req", &r->in.req);
14088                 ndr->depth--;
14089         }
14090         if (flags & NDR_OUT) {
14091                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaDel");
14092                 ndr->depth++;
14093                 ndr_print_WERROR(ndr, "result", r->out.result);
14094                 ndr->depth--;
14095         }
14096         ndr->depth--;
14097 }
14098
14099 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMod(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaMod *r)
14100 {
14101         if (flags & NDR_IN) {
14102                 if (r->in.bind_handle == NULL) {
14103                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14104                 }
14105                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14106                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14107                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
14108                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14109         }
14110         if (flags & NDR_OUT) {
14111                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14112         }
14113         return NDR_ERR_SUCCESS;
14114 }
14115
14116 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMod(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaMod *r)
14117 {
14118         TALLOC_CTX *_mem_save_bind_handle_0;
14119         if (flags & NDR_IN) {
14120                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14121                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14122                 }
14123                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14124                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14125                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14126                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14127                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14128                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
14129                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14130         }
14131         if (flags & NDR_OUT) {
14132                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14133         }
14134         return NDR_ERR_SUCCESS;
14135 }
14136
14137 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r)
14138 {
14139         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMod");
14140         ndr->depth++;
14141         if (flags & NDR_SET_VALUES) {
14142                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14143         }
14144         if (flags & NDR_IN) {
14145                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaMod");
14146                 ndr->depth++;
14147                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14148                 ndr->depth++;
14149                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14150                 ndr->depth--;
14151                 ndr_print_int32(ndr, "level", r->in.level);
14152                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
14153                 ndr_print_drsuapi_DsReplicaModRequest(ndr, "req", &r->in.req);
14154                 ndr->depth--;
14155         }
14156         if (flags & NDR_OUT) {
14157                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaMod");
14158                 ndr->depth++;
14159                 ndr_print_WERROR(ndr, "result", r->out.result);
14160                 ndr->depth--;
14161         }
14162         ndr->depth--;
14163 }
14164
14165 static enum ndr_err_code ndr_push_DRSUAPI_VERIFY_NAMES(struct ndr_push *ndr, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
14166 {
14167         if (flags & NDR_IN) {
14168         }
14169         if (flags & NDR_OUT) {
14170                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14171         }
14172         return NDR_ERR_SUCCESS;
14173 }
14174
14175 static enum ndr_err_code ndr_pull_DRSUAPI_VERIFY_NAMES(struct ndr_pull *ndr, int flags, struct DRSUAPI_VERIFY_NAMES *r)
14176 {
14177         if (flags & NDR_IN) {
14178         }
14179         if (flags & NDR_OUT) {
14180                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14181         }
14182         return NDR_ERR_SUCCESS;
14183 }
14184
14185 _PUBLIC_ void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
14186 {
14187         ndr_print_struct(ndr, name, "DRSUAPI_VERIFY_NAMES");
14188         ndr->depth++;
14189         if (flags & NDR_SET_VALUES) {
14190                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14191         }
14192         if (flags & NDR_IN) {
14193                 ndr_print_struct(ndr, "in", "DRSUAPI_VERIFY_NAMES");
14194                 ndr->depth++;
14195                 ndr->depth--;
14196         }
14197         if (flags & NDR_OUT) {
14198                 ndr_print_struct(ndr, "out", "DRSUAPI_VERIFY_NAMES");
14199                 ndr->depth++;
14200                 ndr_print_WERROR(ndr, "result", r->out.result);
14201                 ndr->depth--;
14202         }
14203         ndr->depth--;
14204 }
14205
14206 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships *r)
14207 {
14208         if (flags & NDR_IN) {
14209                 if (r->in.bind_handle == NULL) {
14210                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14211                 }
14212                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14213                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14214                 if (r->in.req == NULL) {
14215                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14216                 }
14217                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14218                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14219         }
14220         if (flags & NDR_OUT) {
14221                 if (r->out.level_out == NULL) {
14222                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14223                 }
14224                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14225                 if (r->out.ctr == NULL) {
14226                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14227                 }
14228                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14229                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14230                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14231         }
14232         return NDR_ERR_SUCCESS;
14233 }
14234
14235 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships *r)
14236 {
14237         TALLOC_CTX *_mem_save_bind_handle_0;
14238         TALLOC_CTX *_mem_save_req_0;
14239         TALLOC_CTX *_mem_save_level_out_0;
14240         TALLOC_CTX *_mem_save_ctr_0;
14241         if (flags & NDR_IN) {
14242                 ZERO_STRUCT(r->out);
14243
14244                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14245                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14246                 }
14247                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14248                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14249                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14250                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14251                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14252                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14253                         NDR_PULL_ALLOC(ndr, r->in.req);
14254                 }
14255                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14256                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14257                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14258                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14259                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14260                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14261                 ZERO_STRUCTP(r->out.level_out);
14262                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14263                 ZERO_STRUCTP(r->out.ctr);
14264         }
14265         if (flags & NDR_OUT) {
14266                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14267                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14268                 }
14269                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14270                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14271                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14272                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14273                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14274                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14275                 }
14276                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14277                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14278                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14279                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14280                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14281                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14282         }
14283         return NDR_ERR_SUCCESS;
14284 }
14285
14286 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r)
14287 {
14288         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships");
14289         ndr->depth++;
14290         if (flags & NDR_SET_VALUES) {
14291                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14292         }
14293         if (flags & NDR_IN) {
14294                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships");
14295                 ndr->depth++;
14296                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14297                 ndr->depth++;
14298                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14299                 ndr->depth--;
14300                 ndr_print_int32(ndr, "level", r->in.level);
14301                 ndr_print_ptr(ndr, "req", r->in.req);
14302                 ndr->depth++;
14303                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14304                 ndr_print_drsuapi_DsGetMembershipsRequest(ndr, "req", r->in.req);
14305                 ndr->depth--;
14306                 ndr->depth--;
14307         }
14308         if (flags & NDR_OUT) {
14309                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships");
14310                 ndr->depth++;
14311                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14312                 ndr->depth++;
14313                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14314                 ndr->depth--;
14315                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14316                 ndr->depth++;
14317                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14318                 ndr_print_drsuapi_DsGetMembershipsCtr(ndr, "ctr", r->out.ctr);
14319                 ndr->depth--;
14320                 ndr_print_WERROR(ndr, "result", r->out.result);
14321                 ndr->depth--;
14322         }
14323         ndr->depth--;
14324 }
14325
14326 static enum ndr_err_code ndr_push_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_push *ndr, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14327 {
14328         if (flags & NDR_IN) {
14329         }
14330         if (flags & NDR_OUT) {
14331                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14332         }
14333         return NDR_ERR_SUCCESS;
14334 }
14335
14336 static enum ndr_err_code ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_pull *ndr, int flags, struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14337 {
14338         if (flags & NDR_IN) {
14339         }
14340         if (flags & NDR_OUT) {
14341                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14342         }
14343         return NDR_ERR_SUCCESS;
14344 }
14345
14346 _PUBLIC_ void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14347 {
14348         ndr_print_struct(ndr, name, "DRSUAPI_INTER_DOMAIN_MOVE");
14349         ndr->depth++;
14350         if (flags & NDR_SET_VALUES) {
14351                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14352         }
14353         if (flags & NDR_IN) {
14354                 ndr_print_struct(ndr, "in", "DRSUAPI_INTER_DOMAIN_MOVE");
14355                 ndr->depth++;
14356                 ndr->depth--;
14357         }
14358         if (flags & NDR_OUT) {
14359                 ndr_print_struct(ndr, "out", "DRSUAPI_INTER_DOMAIN_MOVE");
14360                 ndr->depth++;
14361                 ndr_print_WERROR(ndr, "result", r->out.result);
14362                 ndr->depth--;
14363         }
14364         ndr->depth--;
14365 }
14366
14367 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLog(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14368 {
14369         if (flags & NDR_IN) {
14370                 if (r->in.bind_handle == NULL) {
14371                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14372                 }
14373                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14375                 if (r->in.req == NULL) {
14376                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14377                 }
14378                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14379                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14380         }
14381         if (flags & NDR_OUT) {
14382                 if (r->out.level_out == NULL) {
14383                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14384                 }
14385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14386                 if (r->out.info == NULL) {
14387                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14388                 }
14389                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.level_out));
14390                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14391                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14392         }
14393         return NDR_ERR_SUCCESS;
14394 }
14395
14396 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLog(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNT4ChangeLog *r)
14397 {
14398         TALLOC_CTX *_mem_save_bind_handle_0;
14399         TALLOC_CTX *_mem_save_req_0;
14400         TALLOC_CTX *_mem_save_level_out_0;
14401         TALLOC_CTX *_mem_save_info_0;
14402         if (flags & NDR_IN) {
14403                 ZERO_STRUCT(r->out);
14404
14405                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14406                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14407                 }
14408                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14409                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14410                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14411                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14413                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14414                         NDR_PULL_ALLOC(ndr, r->in.req);
14415                 }
14416                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14417                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14418                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14419                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14420                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14421                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14422                 ZERO_STRUCTP(r->out.level_out);
14423                 NDR_PULL_ALLOC(ndr, r->out.info);
14424                 ZERO_STRUCTP(r->out.info);
14425         }
14426         if (flags & NDR_OUT) {
14427                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14428                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14429                 }
14430                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14431                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14433                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14434                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14435                         NDR_PULL_ALLOC(ndr, r->out.info);
14436                 }
14437                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14438                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14439                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.level_out));
14440                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14441                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14442                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14443         }
14444         return NDR_ERR_SUCCESS;
14445 }
14446
14447 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLog(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14448 {
14449         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLog");
14450         ndr->depth++;
14451         if (flags & NDR_SET_VALUES) {
14452                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14453         }
14454         if (flags & NDR_IN) {
14455                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNT4ChangeLog");
14456                 ndr->depth++;
14457                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14458                 ndr->depth++;
14459                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14460                 ndr->depth--;
14461                 ndr_print_uint32(ndr, "level", r->in.level);
14462                 ndr_print_ptr(ndr, "req", r->in.req);
14463                 ndr->depth++;
14464                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14465                 ndr_print_drsuapi_DsGetNT4ChangeLogRequest(ndr, "req", r->in.req);
14466                 ndr->depth--;
14467                 ndr->depth--;
14468         }
14469         if (flags & NDR_OUT) {
14470                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNT4ChangeLog");
14471                 ndr->depth++;
14472                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14473                 ndr->depth++;
14474                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14475                 ndr->depth--;
14476                 ndr_print_ptr(ndr, "info", r->out.info);
14477                 ndr->depth++;
14478                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.level_out);
14479                 ndr_print_drsuapi_DsGetNT4ChangeLogInfo(ndr, "info", r->out.info);
14480                 ndr->depth--;
14481                 ndr_print_WERROR(ndr, "result", r->out.result);
14482                 ndr->depth--;
14483         }
14484         ndr->depth--;
14485 }
14486
14487 static enum ndr_err_code ndr_push_drsuapi_DsCrackNames(struct ndr_push *ndr, int flags, const struct drsuapi_DsCrackNames *r)
14488 {
14489         if (flags & NDR_IN) {
14490                 if (r->in.bind_handle == NULL) {
14491                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14492                 }
14493                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14494                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14495                 if (r->in.req == NULL) {
14496                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14497                 }
14498                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14499                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14500         }
14501         if (flags & NDR_OUT) {
14502                 if (r->out.level_out == NULL) {
14503                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14504                 }
14505                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14506                 if (r->out.ctr == NULL) {
14507                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14508                 }
14509                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14510                 NDR_CHECK(ndr_push_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14511                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14512         }
14513         return NDR_ERR_SUCCESS;
14514 }
14515
14516 static enum ndr_err_code ndr_pull_drsuapi_DsCrackNames(struct ndr_pull *ndr, int flags, struct drsuapi_DsCrackNames *r)
14517 {
14518         TALLOC_CTX *_mem_save_bind_handle_0;
14519         TALLOC_CTX *_mem_save_req_0;
14520         TALLOC_CTX *_mem_save_level_out_0;
14521         TALLOC_CTX *_mem_save_ctr_0;
14522         if (flags & NDR_IN) {
14523                 ZERO_STRUCT(r->out);
14524
14525                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14526                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14527                 }
14528                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14529                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14530                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14531                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14532                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14533                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14534                         NDR_PULL_ALLOC(ndr, r->in.req);
14535                 }
14536                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14537                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14538                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14539                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14540                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14541                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14542                 ZERO_STRUCTP(r->out.level_out);
14543                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14544                 ZERO_STRUCTP(r->out.ctr);
14545         }
14546         if (flags & NDR_OUT) {
14547                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14548                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14549                 }
14550                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14551                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14552                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14553                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14554                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14555                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14556                 }
14557                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14558                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14559                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14560                 NDR_CHECK(ndr_pull_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14561                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14562                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14563         }
14564         return NDR_ERR_SUCCESS;
14565 }
14566
14567 _PUBLIC_ void ndr_print_drsuapi_DsCrackNames(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsCrackNames *r)
14568 {
14569         ndr_print_struct(ndr, name, "drsuapi_DsCrackNames");
14570         ndr->depth++;
14571         if (flags & NDR_SET_VALUES) {
14572                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14573         }
14574         if (flags & NDR_IN) {
14575                 ndr_print_struct(ndr, "in", "drsuapi_DsCrackNames");
14576                 ndr->depth++;
14577                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14578                 ndr->depth++;
14579                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14580                 ndr->depth--;
14581                 ndr_print_int32(ndr, "level", r->in.level);
14582                 ndr_print_ptr(ndr, "req", r->in.req);
14583                 ndr->depth++;
14584                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14585                 ndr_print_drsuapi_DsNameRequest(ndr, "req", r->in.req);
14586                 ndr->depth--;
14587                 ndr->depth--;
14588         }
14589         if (flags & NDR_OUT) {
14590                 ndr_print_struct(ndr, "out", "drsuapi_DsCrackNames");
14591                 ndr->depth++;
14592                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14593                 ndr->depth++;
14594                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14595                 ndr->depth--;
14596                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14597                 ndr->depth++;
14598                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14599                 ndr_print_drsuapi_DsNameCtr(ndr, "ctr", r->out.ctr);
14600                 ndr->depth--;
14601                 ndr_print_WERROR(ndr, "result", r->out.result);
14602                 ndr->depth--;
14603         }
14604         ndr->depth--;
14605 }
14606
14607 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpn(struct ndr_push *ndr, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14608 {
14609         if (flags & NDR_IN) {
14610                 if (r->in.bind_handle == NULL) {
14611                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14612                 }
14613                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14614                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14615                 if (r->in.req == NULL) {
14616                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14617                 }
14618                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14619                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14620         }
14621         if (flags & NDR_OUT) {
14622                 if (r->out.level_out == NULL) {
14623                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14624                 }
14625                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14626                 if (r->out.res == NULL) {
14627                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14628                 }
14629                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14630                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14631                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14632         }
14633         return NDR_ERR_SUCCESS;
14634 }
14635
14636 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpn(struct ndr_pull *ndr, int flags, struct drsuapi_DsWriteAccountSpn *r)
14637 {
14638         TALLOC_CTX *_mem_save_bind_handle_0;
14639         TALLOC_CTX *_mem_save_req_0;
14640         TALLOC_CTX *_mem_save_level_out_0;
14641         TALLOC_CTX *_mem_save_res_0;
14642         if (flags & NDR_IN) {
14643                 ZERO_STRUCT(r->out);
14644
14645                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14646                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14647                 }
14648                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14649                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14650                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14651                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14652                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14653                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14654                         NDR_PULL_ALLOC(ndr, r->in.req);
14655                 }
14656                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14657                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14658                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14659                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14660                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14661                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14662                 ZERO_STRUCTP(r->out.level_out);
14663                 NDR_PULL_ALLOC(ndr, r->out.res);
14664                 ZERO_STRUCTP(r->out.res);
14665         }
14666         if (flags & NDR_OUT) {
14667                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14668                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14669                 }
14670                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14671                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14672                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14673                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14674                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14675                         NDR_PULL_ALLOC(ndr, r->out.res);
14676                 }
14677                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14678                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14679                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14680                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14681                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14682                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14683         }
14684         return NDR_ERR_SUCCESS;
14685 }
14686
14687 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpn(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14688 {
14689         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpn");
14690         ndr->depth++;
14691         if (flags & NDR_SET_VALUES) {
14692                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14693         }
14694         if (flags & NDR_IN) {
14695                 ndr_print_struct(ndr, "in", "drsuapi_DsWriteAccountSpn");
14696                 ndr->depth++;
14697                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14698                 ndr->depth++;
14699                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14700                 ndr->depth--;
14701                 ndr_print_int32(ndr, "level", r->in.level);
14702                 ndr_print_ptr(ndr, "req", r->in.req);
14703                 ndr->depth++;
14704                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14705                 ndr_print_drsuapi_DsWriteAccountSpnRequest(ndr, "req", r->in.req);
14706                 ndr->depth--;
14707                 ndr->depth--;
14708         }
14709         if (flags & NDR_OUT) {
14710                 ndr_print_struct(ndr, "out", "drsuapi_DsWriteAccountSpn");
14711                 ndr->depth++;
14712                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14713                 ndr->depth++;
14714                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14715                 ndr->depth--;
14716                 ndr_print_ptr(ndr, "res", r->out.res);
14717                 ndr->depth++;
14718                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14719                 ndr_print_drsuapi_DsWriteAccountSpnResult(ndr, "res", r->out.res);
14720                 ndr->depth--;
14721                 ndr_print_WERROR(ndr, "result", r->out.result);
14722                 ndr->depth--;
14723         }
14724         ndr->depth--;
14725 }
14726
14727 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServer(struct ndr_push *ndr, int flags, const struct drsuapi_DsRemoveDSServer *r)
14728 {
14729         if (flags & NDR_IN) {
14730                 if (r->in.bind_handle == NULL) {
14731                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14732                 }
14733                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14734                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14735                 if (r->in.req == NULL) {
14736                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14737                 }
14738                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14739                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14740         }
14741         if (flags & NDR_OUT) {
14742                 if (r->out.level_out == NULL) {
14743                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14744                 }
14745                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14746                 if (r->out.res == NULL) {
14747                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14748                 }
14749                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14750                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14751                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14752         }
14753         return NDR_ERR_SUCCESS;
14754 }
14755
14756 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServer(struct ndr_pull *ndr, int flags, struct drsuapi_DsRemoveDSServer *r)
14757 {
14758         TALLOC_CTX *_mem_save_bind_handle_0;
14759         TALLOC_CTX *_mem_save_req_0;
14760         TALLOC_CTX *_mem_save_level_out_0;
14761         TALLOC_CTX *_mem_save_res_0;
14762         if (flags & NDR_IN) {
14763                 ZERO_STRUCT(r->out);
14764
14765                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14766                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14767                 }
14768                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14769                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14770                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14771                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14772                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14773                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14774                         NDR_PULL_ALLOC(ndr, r->in.req);
14775                 }
14776                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14777                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14778                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14779                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14780                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14781                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14782                 ZERO_STRUCTP(r->out.level_out);
14783                 NDR_PULL_ALLOC(ndr, r->out.res);
14784                 ZERO_STRUCTP(r->out.res);
14785         }
14786         if (flags & NDR_OUT) {
14787                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14788                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14789                 }
14790                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14791                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14792                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14793                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14794                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14795                         NDR_PULL_ALLOC(ndr, r->out.res);
14796                 }
14797                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14798                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14799                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14800                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14801                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14802                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14803         }
14804         return NDR_ERR_SUCCESS;
14805 }
14806
14807 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServer(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsRemoveDSServer *r)
14808 {
14809         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServer");
14810         ndr->depth++;
14811         if (flags & NDR_SET_VALUES) {
14812                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14813         }
14814         if (flags & NDR_IN) {
14815                 ndr_print_struct(ndr, "in", "drsuapi_DsRemoveDSServer");
14816                 ndr->depth++;
14817                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14818                 ndr->depth++;
14819                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14820                 ndr->depth--;
14821                 ndr_print_int32(ndr, "level", r->in.level);
14822                 ndr_print_ptr(ndr, "req", r->in.req);
14823                 ndr->depth++;
14824                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14825                 ndr_print_drsuapi_DsRemoveDSServerRequest(ndr, "req", r->in.req);
14826                 ndr->depth--;
14827                 ndr->depth--;
14828         }
14829         if (flags & NDR_OUT) {
14830                 ndr_print_struct(ndr, "out", "drsuapi_DsRemoveDSServer");
14831                 ndr->depth++;
14832                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14833                 ndr->depth++;
14834                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14835                 ndr->depth--;
14836                 ndr_print_ptr(ndr, "res", r->out.res);
14837                 ndr->depth++;
14838                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14839                 ndr_print_drsuapi_DsRemoveDSServerResult(ndr, "res", r->out.res);
14840                 ndr->depth--;
14841                 ndr_print_WERROR(ndr, "result", r->out.result);
14842                 ndr->depth--;
14843         }
14844         ndr->depth--;
14845 }
14846
14847 static enum ndr_err_code ndr_push_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_push *ndr, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14848 {
14849         if (flags & NDR_IN) {
14850         }
14851         if (flags & NDR_OUT) {
14852                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14853         }
14854         return NDR_ERR_SUCCESS;
14855 }
14856
14857 static enum ndr_err_code ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_pull *ndr, int flags, struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14858 {
14859         if (flags & NDR_IN) {
14860         }
14861         if (flags & NDR_OUT) {
14862                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14863         }
14864         return NDR_ERR_SUCCESS;
14865 }
14866
14867 _PUBLIC_ void ndr_print_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14868 {
14869         ndr_print_struct(ndr, name, "DRSUAPI_REMOVE_DS_DOMAIN");
14870         ndr->depth++;
14871         if (flags & NDR_SET_VALUES) {
14872                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14873         }
14874         if (flags & NDR_IN) {
14875                 ndr_print_struct(ndr, "in", "DRSUAPI_REMOVE_DS_DOMAIN");
14876                 ndr->depth++;
14877                 ndr->depth--;
14878         }
14879         if (flags & NDR_OUT) {
14880                 ndr_print_struct(ndr, "out", "DRSUAPI_REMOVE_DS_DOMAIN");
14881                 ndr->depth++;
14882                 ndr_print_WERROR(ndr, "result", r->out.result);
14883                 ndr->depth--;
14884         }
14885         ndr->depth--;
14886 }
14887
14888 static enum ndr_err_code ndr_push_drsuapi_DsGetDomainControllerInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14889 {
14890         if (flags & NDR_IN) {
14891                 if (r->in.bind_handle == NULL) {
14892                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14893                 }
14894                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14895                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14896                 if (r->in.req == NULL) {
14897                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14898                 }
14899                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14900                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14901         }
14902         if (flags & NDR_OUT) {
14903                 if (r->out.level_out == NULL) {
14904                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14905                 }
14906                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14907                 if (r->out.ctr == NULL) {
14908                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14909                 }
14910                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14911                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14912                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14913         }
14914         return NDR_ERR_SUCCESS;
14915 }
14916
14917 static enum ndr_err_code ndr_pull_drsuapi_DsGetDomainControllerInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetDomainControllerInfo *r)
14918 {
14919         TALLOC_CTX *_mem_save_bind_handle_0;
14920         TALLOC_CTX *_mem_save_req_0;
14921         TALLOC_CTX *_mem_save_level_out_0;
14922         TALLOC_CTX *_mem_save_ctr_0;
14923         if (flags & NDR_IN) {
14924                 ZERO_STRUCT(r->out);
14925
14926                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14927                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14928                 }
14929                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14930                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14931                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14932                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14933                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14934                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14935                         NDR_PULL_ALLOC(ndr, r->in.req);
14936                 }
14937                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14938                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14939                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14940                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14941                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14942                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14943                 ZERO_STRUCTP(r->out.level_out);
14944                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14945                 ZERO_STRUCTP(r->out.ctr);
14946         }
14947         if (flags & NDR_OUT) {
14948                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14949                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14950                 }
14951                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14952                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14953                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14954                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14955                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14956                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14957                 }
14958                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14959                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14960                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14961                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14962                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14963                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14964         }
14965         return NDR_ERR_SUCCESS;
14966 }
14967
14968 _PUBLIC_ void ndr_print_drsuapi_DsGetDomainControllerInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14969 {
14970         ndr_print_struct(ndr, name, "drsuapi_DsGetDomainControllerInfo");
14971         ndr->depth++;
14972         if (flags & NDR_SET_VALUES) {
14973                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14974         }
14975         if (flags & NDR_IN) {
14976                 ndr_print_struct(ndr, "in", "drsuapi_DsGetDomainControllerInfo");
14977                 ndr->depth++;
14978                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14979                 ndr->depth++;
14980                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14981                 ndr->depth--;
14982                 ndr_print_int32(ndr, "level", r->in.level);
14983                 ndr_print_ptr(ndr, "req", r->in.req);
14984                 ndr->depth++;
14985                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14986                 ndr_print_drsuapi_DsGetDCInfoRequest(ndr, "req", r->in.req);
14987                 ndr->depth--;
14988                 ndr->depth--;
14989         }
14990         if (flags & NDR_OUT) {
14991                 ndr_print_struct(ndr, "out", "drsuapi_DsGetDomainControllerInfo");
14992                 ndr->depth++;
14993                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14994                 ndr->depth++;
14995                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14996                 ndr->depth--;
14997                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14998                 ndr->depth++;
14999                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15000                 ndr_print_drsuapi_DsGetDCInfoCtr(ndr, "ctr", r->out.ctr);
15001                 ndr->depth--;
15002                 ndr_print_WERROR(ndr, "result", r->out.result);
15003                 ndr->depth--;
15004         }
15005         ndr->depth--;
15006 }
15007
15008 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAddEntry(struct ndr_push *ndr, int flags, const struct drsuapi_DsAddEntry *r)
15009 {
15010         if (flags & NDR_IN) {
15011                 if (r->in.bind_handle == NULL) {
15012                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15013                 }
15014                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15015                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15016                 if (r->in.req == NULL) {
15017                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15018                 }
15019                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15020                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15021         }
15022         if (flags & NDR_OUT) {
15023                 if (r->out.level_out == NULL) {
15024                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15025                 }
15026                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15027                 if (r->out.ctr == NULL) {
15028                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15029                 }
15030                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15031                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15032                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15033         }
15034         return NDR_ERR_SUCCESS;
15035 }
15036
15037 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAddEntry(struct ndr_pull *ndr, int flags, struct drsuapi_DsAddEntry *r)
15038 {
15039         TALLOC_CTX *_mem_save_bind_handle_0;
15040         TALLOC_CTX *_mem_save_req_0;
15041         TALLOC_CTX *_mem_save_level_out_0;
15042         TALLOC_CTX *_mem_save_ctr_0;
15043         if (flags & NDR_IN) {
15044                 ZERO_STRUCT(r->out);
15045
15046                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15047                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15048                 }
15049                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15050                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15051                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15052                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15053                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15054                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15055                         NDR_PULL_ALLOC(ndr, r->in.req);
15056                 }
15057                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15058                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15059                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15060                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15061                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15062                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15063                 ZERO_STRUCTP(r->out.level_out);
15064                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15065                 ZERO_STRUCTP(r->out.ctr);
15066         }
15067         if (flags & NDR_OUT) {
15068                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15069                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15070                 }
15071                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15072                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15073                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15074                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15075                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15076                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15077                 }
15078                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15079                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15080                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15081                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15082                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15083                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15084         }
15085         return NDR_ERR_SUCCESS;
15086 }
15087
15088 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsAddEntry *r)
15089 {
15090         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry");
15091         ndr->depth++;
15092         if (flags & NDR_SET_VALUES) {
15093                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15094         }
15095         if (flags & NDR_IN) {
15096                 ndr_print_struct(ndr, "in", "drsuapi_DsAddEntry");
15097                 ndr->depth++;
15098                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15099                 ndr->depth++;
15100                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15101                 ndr->depth--;
15102                 ndr_print_int32(ndr, "level", r->in.level);
15103                 ndr_print_ptr(ndr, "req", r->in.req);
15104                 ndr->depth++;
15105                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15106                 ndr_print_drsuapi_DsAddEntryRequest(ndr, "req", r->in.req);
15107                 ndr->depth--;
15108                 ndr->depth--;
15109         }
15110         if (flags & NDR_OUT) {
15111                 ndr_print_struct(ndr, "out", "drsuapi_DsAddEntry");
15112                 ndr->depth++;
15113                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15114                 ndr->depth++;
15115                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15116                 ndr->depth--;
15117                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15118                 ndr->depth++;
15119                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15120                 ndr_print_drsuapi_DsAddEntryCtr(ndr, "ctr", r->out.ctr);
15121                 ndr->depth--;
15122                 ndr_print_WERROR(ndr, "result", r->out.result);
15123                 ndr->depth--;
15124         }
15125         ndr->depth--;
15126 }
15127
15128 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC(struct ndr_push *ndr, int flags, const struct drsuapi_DsExecuteKCC *r)
15129 {
15130         if (flags & NDR_IN) {
15131                 if (r->in.bind_handle == NULL) {
15132                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15133                 }
15134                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15135                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15136                 if (r->in.req == NULL) {
15137                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15138                 }
15139                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15140                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
15141         }
15142         if (flags & NDR_OUT) {
15143                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15144         }
15145         return NDR_ERR_SUCCESS;
15146 }
15147
15148 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC(struct ndr_pull *ndr, int flags, struct drsuapi_DsExecuteKCC *r)
15149 {
15150         TALLOC_CTX *_mem_save_bind_handle_0;
15151         TALLOC_CTX *_mem_save_req_0;
15152         if (flags & NDR_IN) {
15153                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15154                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15155                 }
15156                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15157                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15158                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15159                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15161                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15162                         NDR_PULL_ALLOC(ndr, r->in.req);
15163                 }
15164                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15165                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15166                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15167                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
15168                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15169         }
15170         if (flags & NDR_OUT) {
15171                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15172         }
15173         return NDR_ERR_SUCCESS;
15174 }
15175
15176 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsExecuteKCC *r)
15177 {
15178         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC");
15179         ndr->depth++;
15180         if (flags & NDR_SET_VALUES) {
15181                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15182         }
15183         if (flags & NDR_IN) {
15184                 ndr_print_struct(ndr, "in", "drsuapi_DsExecuteKCC");
15185                 ndr->depth++;
15186                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15187                 ndr->depth++;
15188                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15189                 ndr->depth--;
15190                 ndr_print_uint32(ndr, "level", r->in.level);
15191                 ndr_print_ptr(ndr, "req", r->in.req);
15192                 ndr->depth++;
15193                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15194                 ndr_print_drsuapi_DsExecuteKCCRequest(ndr, "req", r->in.req);
15195                 ndr->depth--;
15196                 ndr->depth--;
15197         }
15198         if (flags & NDR_OUT) {
15199                 ndr_print_struct(ndr, "out", "drsuapi_DsExecuteKCC");
15200                 ndr->depth++;
15201                 ndr_print_WERROR(ndr, "result", r->out.result);
15202                 ndr->depth--;
15203         }
15204         ndr->depth--;
15205 }
15206
15207 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaGetInfo *r)
15208 {
15209         if (flags & NDR_IN) {
15210                 if (r->in.bind_handle == NULL) {
15211                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15212                 }
15213                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15214                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, r->in.level));
15215                 if (r->in.req == NULL) {
15216                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15217                 }
15218                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15219                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15220         }
15221         if (flags & NDR_OUT) {
15222                 if (r->out.info_type == NULL) {
15223                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15224                 }
15225                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, *r->out.info_type));
15226                 if (r->out.info == NULL) {
15227                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15228                 }
15229                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.info_type));
15230                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15231                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15232         }
15233         return NDR_ERR_SUCCESS;
15234 }
15235
15236 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaGetInfo *r)
15237 {
15238         TALLOC_CTX *_mem_save_bind_handle_0;
15239         TALLOC_CTX *_mem_save_req_0;
15240         TALLOC_CTX *_mem_save_info_type_0;
15241         TALLOC_CTX *_mem_save_info_0;
15242         if (flags & NDR_IN) {
15243                 ZERO_STRUCT(r->out);
15244
15245                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15246                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15247                 }
15248                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15249                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15250                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15251                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15252                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, &r->in.level));
15253                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15254                         NDR_PULL_ALLOC(ndr, r->in.req);
15255                 }
15256                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15257                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15258                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15259                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15260                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15261                 NDR_PULL_ALLOC(ndr, r->out.info_type);
15262                 ZERO_STRUCTP(r->out.info_type);
15263                 NDR_PULL_ALLOC(ndr, r->out.info);
15264                 ZERO_STRUCTP(r->out.info);
15265         }
15266         if (flags & NDR_OUT) {
15267                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15268                         NDR_PULL_ALLOC(ndr, r->out.info_type);
15269                 }
15270                 _mem_save_info_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
15271                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_type, LIBNDR_FLAG_REF_ALLOC);
15272                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->out.info_type));
15273                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_type_0, LIBNDR_FLAG_REF_ALLOC);
15274                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15275                         NDR_PULL_ALLOC(ndr, r->out.info);
15276                 }
15277                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15278                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
15279                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.info_type));
15280                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15281                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15282                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15283         }
15284         return NDR_ERR_SUCCESS;
15285 }
15286
15287 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaGetInfo *r)
15288 {
15289         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfo");
15290         ndr->depth++;
15291         if (flags & NDR_SET_VALUES) {
15292                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15293         }
15294         if (flags & NDR_IN) {
15295                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaGetInfo");
15296                 ndr->depth++;
15297                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15298                 ndr->depth++;
15299                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15300                 ndr->depth--;
15301                 ndr_print_drsuapi_DsReplicaGetInfoLevel(ndr, "level", r->in.level);
15302                 ndr_print_ptr(ndr, "req", r->in.req);
15303                 ndr->depth++;
15304                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15305                 ndr_print_drsuapi_DsReplicaGetInfoRequest(ndr, "req", r->in.req);
15306                 ndr->depth--;
15307                 ndr->depth--;
15308         }
15309         if (flags & NDR_OUT) {
15310                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaGetInfo");
15311                 ndr->depth++;
15312                 ndr_print_ptr(ndr, "info_type", r->out.info_type);
15313                 ndr->depth++;
15314                 ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", *r->out.info_type);
15315                 ndr->depth--;
15316                 ndr_print_ptr(ndr, "info", r->out.info);
15317                 ndr->depth++;
15318                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.info_type);
15319                 ndr_print_drsuapi_DsReplicaInfo(ndr, "info", r->out.info);
15320                 ndr->depth--;
15321                 ndr_print_WERROR(ndr, "result", r->out.result);
15322                 ndr->depth--;
15323         }
15324         ndr->depth--;
15325 }
15326
15327 static enum ndr_err_code ndr_push_DRSUAPI_ADD_SID_HISTORY(struct ndr_push *ndr, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15328 {
15329         if (flags & NDR_IN) {
15330         }
15331         if (flags & NDR_OUT) {
15332                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15333         }
15334         return NDR_ERR_SUCCESS;
15335 }
15336
15337 static enum ndr_err_code ndr_pull_DRSUAPI_ADD_SID_HISTORY(struct ndr_pull *ndr, int flags, struct DRSUAPI_ADD_SID_HISTORY *r)
15338 {
15339         if (flags & NDR_IN) {
15340         }
15341         if (flags & NDR_OUT) {
15342                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15343         }
15344         return NDR_ERR_SUCCESS;
15345 }
15346
15347 _PUBLIC_ void ndr_print_DRSUAPI_ADD_SID_HISTORY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15348 {
15349         ndr_print_struct(ndr, name, "DRSUAPI_ADD_SID_HISTORY");
15350         ndr->depth++;
15351         if (flags & NDR_SET_VALUES) {
15352                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15353         }
15354         if (flags & NDR_IN) {
15355                 ndr_print_struct(ndr, "in", "DRSUAPI_ADD_SID_HISTORY");
15356                 ndr->depth++;
15357                 ndr->depth--;
15358         }
15359         if (flags & NDR_OUT) {
15360                 ndr_print_struct(ndr, "out", "DRSUAPI_ADD_SID_HISTORY");
15361                 ndr->depth++;
15362                 ndr_print_WERROR(ndr, "result", r->out.result);
15363                 ndr->depth--;
15364         }
15365         ndr->depth--;
15366 }
15367
15368 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships2 *r)
15369 {
15370         if (flags & NDR_IN) {
15371                 if (r->in.bind_handle == NULL) {
15372                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15373                 }
15374                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15375                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15376                 if (r->in.req == NULL) {
15377                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15378                 }
15379                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15380                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15381         }
15382         if (flags & NDR_OUT) {
15383                 if (r->out.level_out == NULL) {
15384                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15385                 }
15386                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15387                 if (r->out.ctr == NULL) {
15388                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15389                 }
15390                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15391                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15392                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15393         }
15394         return NDR_ERR_SUCCESS;
15395 }
15396
15397 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships2 *r)
15398 {
15399         TALLOC_CTX *_mem_save_bind_handle_0;
15400         TALLOC_CTX *_mem_save_req_0;
15401         TALLOC_CTX *_mem_save_level_out_0;
15402         TALLOC_CTX *_mem_save_ctr_0;
15403         if (flags & NDR_IN) {
15404                 ZERO_STRUCT(r->out);
15405
15406                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15407                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15408                 }
15409                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15410                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15411                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15412                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15413                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15414                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15415                         NDR_PULL_ALLOC(ndr, r->in.req);
15416                 }
15417                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15418                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15419                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15420                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15421                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15422                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15423                 ZERO_STRUCTP(r->out.level_out);
15424                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15425                 ZERO_STRUCTP(r->out.ctr);
15426         }
15427         if (flags & NDR_OUT) {
15428                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15429                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15430                 }
15431                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15432                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15433                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15434                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15435                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15436                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15437                 }
15438                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15439                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15440                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15441                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15442                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15443                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15444         }
15445         return NDR_ERR_SUCCESS;
15446 }
15447
15448 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships2 *r)
15449 {
15450         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2");
15451         ndr->depth++;
15452         if (flags & NDR_SET_VALUES) {
15453                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15454         }
15455         if (flags & NDR_IN) {
15456                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships2");
15457                 ndr->depth++;
15458                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15459                 ndr->depth++;
15460                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15461                 ndr->depth--;
15462                 ndr_print_int32(ndr, "level", r->in.level);
15463                 ndr_print_ptr(ndr, "req", r->in.req);
15464                 ndr->depth++;
15465                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15466                 ndr_print_drsuapi_DsGetMemberships2Request(ndr, "req", r->in.req);
15467                 ndr->depth--;
15468                 ndr->depth--;
15469         }
15470         if (flags & NDR_OUT) {
15471                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships2");
15472                 ndr->depth++;
15473                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15474                 ndr->depth++;
15475                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15476                 ndr->depth--;
15477                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15478                 ndr->depth++;
15479                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15480                 ndr_print_drsuapi_DsGetMemberships2Ctr(ndr, "ctr", r->out.ctr);
15481                 ndr->depth--;
15482                 ndr_print_WERROR(ndr, "result", r->out.result);
15483                 ndr->depth--;
15484         }
15485         ndr->depth--;
15486 }
15487
15488 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15489 {
15490         if (flags & NDR_IN) {
15491         }
15492         if (flags & NDR_OUT) {
15493                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15494         }
15495         return NDR_ERR_SUCCESS;
15496 }
15497
15498 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15499 {
15500         if (flags & NDR_IN) {
15501         }
15502         if (flags & NDR_OUT) {
15503                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15504         }
15505         return NDR_ERR_SUCCESS;
15506 }
15507
15508 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15509 {
15510         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15511         ndr->depth++;
15512         if (flags & NDR_SET_VALUES) {
15513                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15514         }
15515         if (flags & NDR_IN) {
15516                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15517                 ndr->depth++;
15518                 ndr->depth--;
15519         }
15520         if (flags & NDR_OUT) {
15521                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15522                 ndr->depth++;
15523                 ndr_print_WERROR(ndr, "result", r->out.result);
15524                 ndr->depth--;
15525         }
15526         ndr->depth--;
15527 }
15528
15529 static enum ndr_err_code ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_push *ndr, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15530 {
15531         if (flags & NDR_IN) {
15532         }
15533         if (flags & NDR_OUT) {
15534                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15535         }
15536         return NDR_ERR_SUCCESS;
15537 }
15538
15539 static enum ndr_err_code ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_pull *ndr, int flags, struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15540 {
15541         if (flags & NDR_IN) {
15542         }
15543         if (flags & NDR_OUT) {
15544                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15545         }
15546         return NDR_ERR_SUCCESS;
15547 }
15548
15549 _PUBLIC_ void ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15550 {
15551         ndr_print_struct(ndr, name, "DRSUAPI_GET_OBJECT_EXISTENCE");
15552         ndr->depth++;
15553         if (flags & NDR_SET_VALUES) {
15554                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15555         }
15556         if (flags & NDR_IN) {
15557                 ndr_print_struct(ndr, "in", "DRSUAPI_GET_OBJECT_EXISTENCE");
15558                 ndr->depth++;
15559                 ndr->depth--;
15560         }
15561         if (flags & NDR_OUT) {
15562                 ndr_print_struct(ndr, "out", "DRSUAPI_GET_OBJECT_EXISTENCE");
15563                 ndr->depth++;
15564                 ndr_print_WERROR(ndr, "result", r->out.result);
15565                 ndr->depth--;
15566         }
15567         ndr->depth--;
15568 }
15569
15570 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCost(struct ndr_push *ndr, int flags, const struct drsuapi_QuerySitesByCost *r)
15571 {
15572         if (flags & NDR_IN) {
15573                 if (r->in.bind_handle == NULL) {
15574                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15575                 }
15576                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15577                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15578                 if (r->in.req == NULL) {
15579                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15580                 }
15581                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15582                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15583         }
15584         if (flags & NDR_OUT) {
15585                 if (r->out.level_out == NULL) {
15586                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15587                 }
15588                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15589                 if (r->out.ctr == NULL) {
15590                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15591                 }
15592                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15593                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15594                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15595         }
15596         return NDR_ERR_SUCCESS;
15597 }
15598
15599 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCost(struct ndr_pull *ndr, int flags, struct drsuapi_QuerySitesByCost *r)
15600 {
15601         TALLOC_CTX *_mem_save_bind_handle_0;
15602         TALLOC_CTX *_mem_save_req_0;
15603         TALLOC_CTX *_mem_save_level_out_0;
15604         TALLOC_CTX *_mem_save_ctr_0;
15605         if (flags & NDR_IN) {
15606                 ZERO_STRUCT(r->out);
15607
15608                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15609                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15610                 }
15611                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15612                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15613                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15614                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15615                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15616                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15617                         NDR_PULL_ALLOC(ndr, r->in.req);
15618                 }
15619                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15620                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15621                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15622                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15623                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15624                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15625                 ZERO_STRUCTP(r->out.level_out);
15626                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15627                 ZERO_STRUCTP(r->out.ctr);
15628         }
15629         if (flags & NDR_OUT) {
15630                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15631                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15632                 }
15633                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15634                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15635                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15636                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15637                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15638                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15639                 }
15640                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15641                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15642                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15643                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15644                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15645                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15646         }
15647         return NDR_ERR_SUCCESS;
15648 }
15649
15650 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCost(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_QuerySitesByCost *r)
15651 {
15652         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCost");
15653         ndr->depth++;
15654         if (flags & NDR_SET_VALUES) {
15655                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15656         }
15657         if (flags & NDR_IN) {
15658                 ndr_print_struct(ndr, "in", "drsuapi_QuerySitesByCost");
15659                 ndr->depth++;
15660                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15661                 ndr->depth++;
15662                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15663                 ndr->depth--;
15664                 ndr_print_int32(ndr, "level", r->in.level);
15665                 ndr_print_ptr(ndr, "req", r->in.req);
15666                 ndr->depth++;
15667                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15668                 ndr_print_drsuapi_QuerySitesByCostRequest(ndr, "req", r->in.req);
15669                 ndr->depth--;
15670                 ndr->depth--;
15671         }
15672         if (flags & NDR_OUT) {
15673                 ndr_print_struct(ndr, "out", "drsuapi_QuerySitesByCost");
15674                 ndr->depth++;
15675                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15676                 ndr->depth++;
15677                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15678                 ndr->depth--;
15679                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15680                 ndr->depth++;
15681                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15682                 ndr_print_drsuapi_QuerySitesByCostCtr(ndr, "ctr", r->out.ctr);
15683                 ndr->depth--;
15684                 ndr_print_WERROR(ndr, "result", r->out.result);
15685                 ndr->depth--;
15686         }
15687         ndr->depth--;
15688 }
15689
15690 static const struct ndr_interface_call drsuapi_calls[] = {
15691         {
15692                 "drsuapi_DsBind",
15693                 sizeof(struct drsuapi_DsBind),
15694                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsBind,
15695                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsBind,
15696                 (ndr_print_function_t) ndr_print_drsuapi_DsBind,
15697                 false,
15698         },
15699         {
15700                 "drsuapi_DsUnbind",
15701                 sizeof(struct drsuapi_DsUnbind),
15702                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsUnbind,
15703                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsUnbind,
15704                 (ndr_print_function_t) ndr_print_drsuapi_DsUnbind,
15705                 false,
15706         },
15707         {
15708                 "drsuapi_DsReplicaSync",
15709                 sizeof(struct drsuapi_DsReplicaSync),
15710                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaSync,
15711                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaSync,
15712                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaSync,
15713                 false,
15714         },
15715         {
15716                 "drsuapi_DsGetNCChanges",
15717                 sizeof(struct drsuapi_DsGetNCChanges),
15718                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNCChanges,
15719                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNCChanges,
15720                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNCChanges,
15721                 false,
15722         },
15723         {
15724                 "drsuapi_DsReplicaUpdateRefs",
15725                 sizeof(struct drsuapi_DsReplicaUpdateRefs),
15726                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaUpdateRefs,
15727                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaUpdateRefs,
15728                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaUpdateRefs,
15729                 false,
15730         },
15731         {
15732                 "drsuapi_DsReplicaAdd",
15733                 sizeof(struct drsuapi_DsReplicaAdd),
15734                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaAdd,
15735                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaAdd,
15736                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaAdd,
15737                 false,
15738         },
15739         {
15740                 "drsuapi_DsReplicaDel",
15741                 sizeof(struct drsuapi_DsReplicaDel),
15742                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaDel,
15743                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaDel,
15744                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaDel,
15745                 false,
15746         },
15747         {
15748                 "drsuapi_DsReplicaMod",
15749                 sizeof(struct drsuapi_DsReplicaMod),
15750                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaMod,
15751                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaMod,
15752                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaMod,
15753                 false,
15754         },
15755         {
15756                 "DRSUAPI_VERIFY_NAMES",
15757                 sizeof(struct DRSUAPI_VERIFY_NAMES),
15758                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_VERIFY_NAMES,
15759                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_VERIFY_NAMES,
15760                 (ndr_print_function_t) ndr_print_DRSUAPI_VERIFY_NAMES,
15761                 false,
15762         },
15763         {
15764                 "drsuapi_DsGetMemberships",
15765                 sizeof(struct drsuapi_DsGetMemberships),
15766                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships,
15767                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships,
15768                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships,
15769                 false,
15770         },
15771         {
15772                 "DRSUAPI_INTER_DOMAIN_MOVE",
15773                 sizeof(struct DRSUAPI_INTER_DOMAIN_MOVE),
15774                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_INTER_DOMAIN_MOVE,
15775                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE,
15776                 (ndr_print_function_t) ndr_print_DRSUAPI_INTER_DOMAIN_MOVE,
15777                 false,
15778         },
15779         {
15780                 "drsuapi_DsGetNT4ChangeLog",
15781                 sizeof(struct drsuapi_DsGetNT4ChangeLog),
15782                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNT4ChangeLog,
15783                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNT4ChangeLog,
15784                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNT4ChangeLog,
15785                 false,
15786         },
15787         {
15788                 "drsuapi_DsCrackNames",
15789                 sizeof(struct drsuapi_DsCrackNames),
15790                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsCrackNames,
15791                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsCrackNames,
15792                 (ndr_print_function_t) ndr_print_drsuapi_DsCrackNames,
15793                 false,
15794         },
15795         {
15796                 "drsuapi_DsWriteAccountSpn",
15797                 sizeof(struct drsuapi_DsWriteAccountSpn),
15798                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsWriteAccountSpn,
15799                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsWriteAccountSpn,
15800                 (ndr_print_function_t) ndr_print_drsuapi_DsWriteAccountSpn,
15801                 false,
15802         },
15803         {
15804                 "drsuapi_DsRemoveDSServer",
15805                 sizeof(struct drsuapi_DsRemoveDSServer),
15806                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsRemoveDSServer,
15807                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsRemoveDSServer,
15808                 (ndr_print_function_t) ndr_print_drsuapi_DsRemoveDSServer,
15809                 false,
15810         },
15811         {
15812                 "DRSUAPI_REMOVE_DS_DOMAIN",
15813                 sizeof(struct DRSUAPI_REMOVE_DS_DOMAIN),
15814                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REMOVE_DS_DOMAIN,
15815                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN,
15816                 (ndr_print_function_t) ndr_print_DRSUAPI_REMOVE_DS_DOMAIN,
15817                 false,
15818         },
15819         {
15820                 "drsuapi_DsGetDomainControllerInfo",
15821                 sizeof(struct drsuapi_DsGetDomainControllerInfo),
15822                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetDomainControllerInfo,
15823                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetDomainControllerInfo,
15824                 (ndr_print_function_t) ndr_print_drsuapi_DsGetDomainControllerInfo,
15825                 false,
15826         },
15827         {
15828                 "drsuapi_DsAddEntry",
15829                 sizeof(struct drsuapi_DsAddEntry),
15830                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsAddEntry,
15831                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsAddEntry,
15832                 (ndr_print_function_t) ndr_print_drsuapi_DsAddEntry,
15833                 false,
15834         },
15835         {
15836                 "drsuapi_DsExecuteKCC",
15837                 sizeof(struct drsuapi_DsExecuteKCC),
15838                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsExecuteKCC,
15839                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsExecuteKCC,
15840                 (ndr_print_function_t) ndr_print_drsuapi_DsExecuteKCC,
15841                 false,
15842         },
15843         {
15844                 "drsuapi_DsReplicaGetInfo",
15845                 sizeof(struct drsuapi_DsReplicaGetInfo),
15846                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaGetInfo,
15847                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaGetInfo,
15848                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaGetInfo,
15849                 false,
15850         },
15851         {
15852                 "DRSUAPI_ADD_SID_HISTORY",
15853                 sizeof(struct DRSUAPI_ADD_SID_HISTORY),
15854                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_ADD_SID_HISTORY,
15855                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_ADD_SID_HISTORY,
15856                 (ndr_print_function_t) ndr_print_DRSUAPI_ADD_SID_HISTORY,
15857                 false,
15858         },
15859         {
15860                 "drsuapi_DsGetMemberships2",
15861                 sizeof(struct drsuapi_DsGetMemberships2),
15862                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships2,
15863                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships2,
15864                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships2,
15865                 false,
15866         },
15867         {
15868                 "DRSUAPI_REPLICA_VERIFY_OBJECTS",
15869                 sizeof(struct DRSUAPI_REPLICA_VERIFY_OBJECTS),
15870                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15871                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15872                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15873                 false,
15874         },
15875         {
15876                 "DRSUAPI_GET_OBJECT_EXISTENCE",
15877                 sizeof(struct DRSUAPI_GET_OBJECT_EXISTENCE),
15878                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE,
15879                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE,
15880                 (ndr_print_function_t) ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE,
15881                 false,
15882         },
15883         {
15884                 "drsuapi_QuerySitesByCost",
15885                 sizeof(struct drsuapi_QuerySitesByCost),
15886                 (ndr_push_flags_fn_t) ndr_push_drsuapi_QuerySitesByCost,
15887                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_QuerySitesByCost,
15888                 (ndr_print_function_t) ndr_print_drsuapi_QuerySitesByCost,
15889                 false,
15890         },
15891         { NULL, 0, NULL, NULL, NULL, false }
15892 };
15893
15894 static const char * const drsuapi_endpoint_strings[] = {
15895         "ncacn_np:[\\pipe\\lsass]",
15896         "ncacn_np:[\\pipe\\protected_storage]",
15897         "ncacn_ip_tcp:",
15898         "ncalrpc:",
15899 };
15900
15901 static const struct ndr_interface_string_array drsuapi_endpoints = {
15902         .count  = 4,
15903         .names  = drsuapi_endpoint_strings
15904 };
15905
15906 static const char * const drsuapi_authservice_strings[] = {
15907         "ldap",
15908 };
15909
15910 static const struct ndr_interface_string_array drsuapi_authservices = {
15911         .count  = 1,
15912         .names  = drsuapi_authservice_strings
15913 };
15914
15915
15916 const struct ndr_interface_table ndr_table_drsuapi = {
15917         .name           = "drsuapi",
15918         .syntax_id      = {
15919                 {0xe3514235,0x4b06,0x11d1,{0xab,0x04},{0x00,0xc0,0x4f,0xc2,0xdc,0xd2}},
15920                 NDR_DRSUAPI_VERSION
15921         },
15922         .helpstring     = NDR_DRSUAPI_HELPSTRING,
15923         .num_calls      = 25,
15924         .calls          = drsuapi_calls,
15925         .endpoints      = &drsuapi_endpoints,
15926         .authservices   = &drsuapi_authservices
15927 };
15928