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 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOID(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOID *r)
1171 {
1172         if (ndr_flags & NDR_SCALARS) {
1173                 NDR_CHECK(ndr_push_align(ndr, 5));
1174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
1175                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary_oid));
1176                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1177         }
1178         if (ndr_flags & NDR_BUFFERS) {
1179                 if (r->binary_oid) {
1180                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
1181                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->binary_oid, r->length));
1182                 }
1183         }
1184         return NDR_ERR_SUCCESS;
1185 }
1186
1187 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOID(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOID *r)
1188 {
1189         uint32_t _ptr_binary_oid;
1190         TALLOC_CTX *_mem_save_binary_oid_0;
1191         if (ndr_flags & NDR_SCALARS) {
1192                 NDR_CHECK(ndr_pull_align(ndr, 5));
1193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
1194                 if (r->length > 10000) {
1195                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1196                 }
1197                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_oid));
1198                 if (_ptr_binary_oid) {
1199                         NDR_PULL_ALLOC(ndr, r->binary_oid);
1200                 } else {
1201                         r->binary_oid = NULL;
1202                 }
1203                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1204         }
1205         if (ndr_flags & NDR_BUFFERS) {
1206                 if (r->binary_oid) {
1207                         _mem_save_binary_oid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1208                         NDR_PULL_SET_MEM_CTX(ndr, r->binary_oid, 0);
1209                         NDR_CHECK(ndr_pull_array_size(ndr, &r->binary_oid));
1210                         NDR_PULL_ALLOC_N(ndr, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid));
1211                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid)));
1212                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_oid_0, 0);
1213                 }
1214                 if (r->binary_oid) {
1215                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->binary_oid, r->length));
1216                 }
1217         }
1218         return NDR_ERR_SUCCESS;
1219 }
1220
1221 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping *r)
1222 {
1223         if (ndr_flags & NDR_SCALARS) {
1224                 NDR_CHECK(ndr_push_align(ndr, 5));
1225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id_prefix));
1226                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1227                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1228         }
1229         if (ndr_flags & NDR_BUFFERS) {
1230                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1231         }
1232         return NDR_ERR_SUCCESS;
1233 }
1234
1235 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping *r)
1236 {
1237         if (ndr_flags & NDR_SCALARS) {
1238                 NDR_CHECK(ndr_pull_align(ndr, 5));
1239                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id_prefix));
1240                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1241                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1242         }
1243         if (ndr_flags & NDR_BUFFERS) {
1244                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1245         }
1246         return NDR_ERR_SUCCESS;
1247 }
1248
1249 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping *r)
1250 {
1251         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping");
1252         ndr->depth++;
1253         ndr_print_uint32(ndr, "id_prefix", r->id_prefix);
1254         ndr_print_drsuapi_DsReplicaOID(ndr, "oid", &r->oid);
1255         ndr->depth--;
1256 }
1257
1258 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1259 {
1260         uint32_t cntr_mappings_1;
1261         if (ndr_flags & NDR_SCALARS) {
1262                 NDR_CHECK(ndr_push_align(ndr, 5));
1263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
1264                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mappings));
1265                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1266         }
1267         if (ndr_flags & NDR_BUFFERS) {
1268                 if (r->mappings) {
1269                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_mappings));
1270                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1271                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1272                         }
1273                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1274                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1275                         }
1276                 }
1277         }
1278         return NDR_ERR_SUCCESS;
1279 }
1280
1281 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1282 {
1283         uint32_t _ptr_mappings;
1284         uint32_t cntr_mappings_1;
1285         TALLOC_CTX *_mem_save_mappings_0;
1286         TALLOC_CTX *_mem_save_mappings_1;
1287         if (ndr_flags & NDR_SCALARS) {
1288                 NDR_CHECK(ndr_pull_align(ndr, 5));
1289                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mappings));
1290                 if (r->num_mappings > 0x100000) {
1291                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1292                 }
1293                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mappings));
1294                 if (_ptr_mappings) {
1295                         NDR_PULL_ALLOC(ndr, r->mappings);
1296                 } else {
1297                         r->mappings = NULL;
1298                 }
1299                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1300         }
1301         if (ndr_flags & NDR_BUFFERS) {
1302                 if (r->mappings) {
1303                         _mem_save_mappings_0 = NDR_PULL_GET_MEM_CTX(ndr);
1304                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1305                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mappings));
1306                         NDR_PULL_ALLOC_N(ndr, r->mappings, ndr_get_array_size(ndr, &r->mappings));
1307                         _mem_save_mappings_1 = NDR_PULL_GET_MEM_CTX(ndr);
1308                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1309                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1310                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1311                         }
1312                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1313                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1314                         }
1315                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_1, 0);
1316                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_0, 0);
1317                 }
1318                 if (r->mappings) {
1319                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->mappings, r->num_mappings));
1320                 }
1321         }
1322         return NDR_ERR_SUCCESS;
1323 }
1324
1325 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1326 {
1327         uint32_t cntr_mappings_1;
1328         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping_Ctr");
1329         ndr->depth++;
1330         ndr_print_uint32(ndr, "num_mappings", r->num_mappings);
1331         ndr_print_ptr(ndr, "mappings", r->mappings);
1332         ndr->depth++;
1333         if (r->mappings) {
1334                 ndr->print(ndr, "%s: ARRAY(%d)", "mappings", (int)r->num_mappings);
1335                 ndr->depth++;
1336                 for (cntr_mappings_1=0;cntr_mappings_1<r->num_mappings;cntr_mappings_1++) {
1337                         char *idx_1=NULL;
1338                         if (asprintf(&idx_1, "[%d]", cntr_mappings_1) != -1) {
1339                                 ndr_print_drsuapi_DsReplicaOIDMapping(ndr, "mappings", &r->mappings[cntr_mappings_1]);
1340                                 free(idx_1);
1341                         }
1342                 }
1343                 ndr->depth--;
1344         }
1345         ndr->depth--;
1346         ndr->depth--;
1347 }
1348
1349 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAttributeId(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsAttributeId r)
1350 {
1351         {
1352                 uint32_t _flags_save_ENUM = ndr->flags;
1353                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1354                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1355                 ndr->flags = _flags_save_ENUM;
1356         }
1357         return NDR_ERR_SUCCESS;
1358 }
1359
1360 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAttributeId(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsAttributeId *r)
1361 {
1362         uint32_t v;
1363         {
1364                 uint32_t _flags_save_ENUM = ndr->flags;
1365                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1366                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1367                 *r = v;
1368                 ndr->flags = _flags_save_ENUM;
1369         }
1370         return NDR_ERR_SUCCESS;
1371 }
1372
1373 _PUBLIC_ void ndr_print_drsuapi_DsAttributeId(struct ndr_print *ndr, const char *name, enum drsuapi_DsAttributeId r)
1374 {
1375         const char *val = NULL;
1376
1377         {
1378                 uint32_t _flags_save_ENUM = ndr->flags;
1379                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1380                 switch (r) {
1381                         case DRSUAPI_ATTRIBUTE_objectClass: val = "DRSUAPI_ATTRIBUTE_objectClass"; break;
1382                         case DRSUAPI_ATTRIBUTE_description: val = "DRSUAPI_ATTRIBUTE_description"; break;
1383                         case DRSUAPI_ATTRIBUTE_member: val = "DRSUAPI_ATTRIBUTE_member"; break;
1384                         case DRSUAPI_ATTRIBUTE_instanceType: val = "DRSUAPI_ATTRIBUTE_instanceType"; break;
1385                         case DRSUAPI_ATTRIBUTE_whenCreated: val = "DRSUAPI_ATTRIBUTE_whenCreated"; break;
1386                         case DRSUAPI_ATTRIBUTE_possSuperiors: val = "DRSUAPI_ATTRIBUTE_possSuperiors"; break;
1387                         case DRSUAPI_ATTRIBUTE_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_hasMasterNCs"; break;
1388                         case DRSUAPI_ATTRIBUTE_subClassOf: val = "DRSUAPI_ATTRIBUTE_subClassOf"; break;
1389                         case DRSUAPI_ATTRIBUTE_governsID: val = "DRSUAPI_ATTRIBUTE_governsID"; break;
1390                         case DRSUAPI_ATTRIBUTE_mustContain: val = "DRSUAPI_ATTRIBUTE_mustContain"; break;
1391                         case DRSUAPI_ATTRIBUTE_mayContain: val = "DRSUAPI_ATTRIBUTE_mayContain"; break;
1392                         case DRSUAPI_ATTRIBUTE_attributeID: val = "DRSUAPI_ATTRIBUTE_attributeID"; break;
1393                         case DRSUAPI_ATTRIBUTE_attributeSyntax: val = "DRSUAPI_ATTRIBUTE_attributeSyntax"; break;
1394                         case DRSUAPI_ATTRIBUTE_isSingleValued: val = "DRSUAPI_ATTRIBUTE_isSingleValued"; break;
1395                         case DRSUAPI_ATTRIBUTE_rangeLower: val = "DRSUAPI_ATTRIBUTE_rangeLower"; break;
1396                         case DRSUAPI_ATTRIBUTE_rangeUpper: val = "DRSUAPI_ATTRIBUTE_rangeUpper"; break;
1397                         case DRSUAPI_ATTRIBUTE_dMDLocation: val = "DRSUAPI_ATTRIBUTE_dMDLocation"; break;
1398                         case DRSUAPI_ATTRIBUTE_objectVersion: val = "DRSUAPI_ATTRIBUTE_objectVersion"; break;
1399                         case DRSUAPI_ATTRIBUTE_invocationId: val = "DRSUAPI_ATTRIBUTE_invocationId"; break;
1400                         case DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly: val = "DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly"; break;
1401                         case DRSUAPI_ATTRIBUTE_adminDisplayName: val = "DRSUAPI_ATTRIBUTE_adminDisplayName"; break;
1402                         case DRSUAPI_ATTRIBUTE_adminDescription: val = "DRSUAPI_ATTRIBUTE_adminDescription"; break;
1403                         case DRSUAPI_ATTRIBUTE_oMSyntax: val = "DRSUAPI_ATTRIBUTE_oMSyntax"; break;
1404                         case DRSUAPI_ATTRIBUTE_ntSecurityDescriptor: val = "DRSUAPI_ATTRIBUTE_ntSecurityDescriptor"; break;
1405                         case DRSUAPI_ATTRIBUTE_searchFlags: val = "DRSUAPI_ATTRIBUTE_searchFlags"; break;
1406                         case DRSUAPI_ATTRIBUTE_auxiliaryClass: val = "DRSUAPI_ATTRIBUTE_auxiliaryClass"; break;
1407                         case DRSUAPI_ATTRIBUTE_lDAPDisplayName: val = "DRSUAPI_ATTRIBUTE_lDAPDisplayName"; break;
1408                         case DRSUAPI_ATTRIBUTE_name: val = "DRSUAPI_ATTRIBUTE_name"; break;
1409                         case DRSUAPI_ATTRIBUTE_userAccountControl: val = "DRSUAPI_ATTRIBUTE_userAccountControl"; break;
1410                         case DRSUAPI_ATTRIBUTE_currentValue: val = "DRSUAPI_ATTRIBUTE_currentValue"; break;
1411                         case DRSUAPI_ATTRIBUTE_homeDirectory: val = "DRSUAPI_ATTRIBUTE_homeDirectory"; break;
1412                         case DRSUAPI_ATTRIBUTE_homeDrive: val = "DRSUAPI_ATTRIBUTE_homeDrive"; break;
1413                         case DRSUAPI_ATTRIBUTE_scriptPath: val = "DRSUAPI_ATTRIBUTE_scriptPath"; break;
1414                         case DRSUAPI_ATTRIBUTE_profilePath: val = "DRSUAPI_ATTRIBUTE_profilePath"; break;
1415                         case DRSUAPI_ATTRIBUTE_objectSid: val = "DRSUAPI_ATTRIBUTE_objectSid"; break;
1416                         case DRSUAPI_ATTRIBUTE_schemaIDGUID: val = "DRSUAPI_ATTRIBUTE_schemaIDGUID"; break;
1417                         case DRSUAPI_ATTRIBUTE_dBCSPwd: val = "DRSUAPI_ATTRIBUTE_dBCSPwd"; break;
1418                         case DRSUAPI_ATTRIBUTE_logonHours: val = "DRSUAPI_ATTRIBUTE_logonHours"; break;
1419                         case DRSUAPI_ATTRIBUTE_userWorkstations: val = "DRSUAPI_ATTRIBUTE_userWorkstations"; break;
1420                         case DRSUAPI_ATTRIBUTE_unicodePwd: val = "DRSUAPI_ATTRIBUTE_unicodePwd"; break;
1421                         case DRSUAPI_ATTRIBUTE_ntPwdHistory: val = "DRSUAPI_ATTRIBUTE_ntPwdHistory"; break;
1422                         case DRSUAPI_ATTRIBUTE_priorValue: val = "DRSUAPI_ATTRIBUTE_priorValue"; break;
1423                         case DRSUAPI_ATTRIBUTE_supplementalCredentials: val = "DRSUAPI_ATTRIBUTE_supplementalCredentials"; break;
1424                         case DRSUAPI_ATTRIBUTE_trustAuthIncoming: val = "DRSUAPI_ATTRIBUTE_trustAuthIncoming"; break;
1425                         case DRSUAPI_ATTRIBUTE_trustAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_trustAuthOutgoing"; break;
1426                         case DRSUAPI_ATTRIBUTE_lmPwdHistory: val = "DRSUAPI_ATTRIBUTE_lmPwdHistory"; break;
1427                         case DRSUAPI_ATTRIBUTE_systemPossSuperiors: val = "DRSUAPI_ATTRIBUTE_systemPossSuperiors"; break;
1428                         case DRSUAPI_ATTRIBUTE_systemMayContain: val = "DRSUAPI_ATTRIBUTE_systemMayContain"; break;
1429                         case DRSUAPI_ATTRIBUTE_systemMustContain: val = "DRSUAPI_ATTRIBUTE_systemMustContain"; break;
1430                         case DRSUAPI_ATTRIBUTE_sAMAccountName: val = "DRSUAPI_ATTRIBUTE_sAMAccountName"; break;
1431                         case DRSUAPI_ATTRIBUTE_sAMAccountType: val = "DRSUAPI_ATTRIBUTE_sAMAccountType"; break;
1432                         case DRSUAPI_ATTRIBUTE_fSMORoleOwner: val = "DRSUAPI_ATTRIBUTE_fSMORoleOwner"; break;
1433                         case DRSUAPI_ATTRIBUTE_systemFlags: val = "DRSUAPI_ATTRIBUTE_systemFlags"; break;
1434                         case DRSUAPI_ATTRIBUTE_serverReference: val = "DRSUAPI_ATTRIBUTE_serverReference"; break;
1435                         case DRSUAPI_ATTRIBUTE_serverReferenceBL: val = "DRSUAPI_ATTRIBUTE_serverReferenceBL"; break;
1436                         case DRSUAPI_ATTRIBUTE_initialAuthIncoming: val = "DRSUAPI_ATTRIBUTE_initialAuthIncoming"; break;
1437                         case DRSUAPI_ATTRIBUTE_initialAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_initialAuthOutgoing"; break;
1438                         case DRSUAPI_ATTRIBUTE_wellKnownObjects: val = "DRSUAPI_ATTRIBUTE_wellKnownObjects"; break;
1439                         case DRSUAPI_ATTRIBUTE_dNSHostName: val = "DRSUAPI_ATTRIBUTE_dNSHostName"; break;
1440                         case DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet: val = "DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet"; break;
1441                         case DRSUAPI_ATTRIBUTE_userPrincipalName: val = "DRSUAPI_ATTRIBUTE_userPrincipalName"; break;
1442                         case DRSUAPI_ATTRIBUTE_groupType: val = "DRSUAPI_ATTRIBUTE_groupType"; break;
1443                         case DRSUAPI_ATTRIBUTE_servicePrincipalName: val = "DRSUAPI_ATTRIBUTE_servicePrincipalName"; break;
1444                         case DRSUAPI_ATTRIBUTE_objectCategory: val = "DRSUAPI_ATTRIBUTE_objectCategory"; break;
1445                         case DRSUAPI_ATTRIBUTE_gPLink: val = "DRSUAPI_ATTRIBUTE_gPLink"; break;
1446                         case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version: val = "DRSUAPI_ATTRIBUTE_msDS_Behavior_Version"; break;
1447                         case DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber: val = "DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber"; break;
1448                         case DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs: val = "DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs"; break;
1449                         case DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs"; break;
1450                 }
1451                 ndr_print_enum(ndr, name, "ENUM", val, r);
1452                 ndr->flags = _flags_save_ENUM;
1453         }
1454 }
1455
1456 static enum ndr_err_code ndr_push_drsuapi_DsPartialAttributeSet(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsPartialAttributeSet *r)
1457 {
1458         uint32_t cntr_attids_0;
1459         if (ndr_flags & NDR_SCALARS) {
1460                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attids));
1461                 NDR_CHECK(ndr_push_align(ndr, 4));
1462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
1463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
1465                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1466                         NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attids[cntr_attids_0]));
1467                 }
1468                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1469         }
1470         if (ndr_flags & NDR_BUFFERS) {
1471         }
1472         return NDR_ERR_SUCCESS;
1473 }
1474
1475 static enum ndr_err_code ndr_pull_drsuapi_DsPartialAttributeSet(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsPartialAttributeSet *r)
1476 {
1477         uint32_t cntr_attids_0;
1478         TALLOC_CTX *_mem_save_attids_0;
1479         if (ndr_flags & NDR_SCALARS) {
1480                 NDR_CHECK(ndr_pull_array_size(ndr, &r->attids));
1481                 NDR_CHECK(ndr_pull_align(ndr, 4));
1482                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1484                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attids));
1485                 if (r->num_attids < 1 || r->num_attids > 0x100000) {
1486                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1487                 }
1488                 NDR_PULL_ALLOC_N(ndr, r->attids, ndr_get_array_size(ndr, &r->attids));
1489                 _mem_save_attids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1490                 NDR_PULL_SET_MEM_CTX(ndr, r->attids, 0);
1491                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1492                         NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attids[cntr_attids_0]));
1493                 }
1494                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attids_0, 0);
1495                 if (r->attids) {
1496                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attids, r->num_attids));
1497                 }
1498                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1499         }
1500         if (ndr_flags & NDR_BUFFERS) {
1501         }
1502         return NDR_ERR_SUCCESS;
1503 }
1504
1505 _PUBLIC_ void ndr_print_drsuapi_DsPartialAttributeSet(struct ndr_print *ndr, const char *name, const struct drsuapi_DsPartialAttributeSet *r)
1506 {
1507         uint32_t cntr_attids_0;
1508         ndr_print_struct(ndr, name, "drsuapi_DsPartialAttributeSet");
1509         ndr->depth++;
1510         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
1511         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1512         ndr_print_uint32(ndr, "num_attids", r->num_attids);
1513         ndr->print(ndr, "%s: ARRAY(%d)", "attids", (int)r->num_attids);
1514         ndr->depth++;
1515         for (cntr_attids_0=0;cntr_attids_0<r->num_attids;cntr_attids_0++) {
1516                 char *idx_0=NULL;
1517                 if (asprintf(&idx_0, "[%d]", cntr_attids_0) != -1) {
1518                         ndr_print_drsuapi_DsAttributeId(ndr, "attids", r->attids[cntr_attids_0]);
1519                         free(idx_0);
1520                 }
1521         }
1522         ndr->depth--;
1523         ndr->depth--;
1524 }
1525
1526 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest8(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest8 *r)
1527 {
1528         if (ndr_flags & NDR_SCALARS) {
1529                 NDR_CHECK(ndr_push_align(ndr, 8));
1530                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1531                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1532                 if (r->naming_context == NULL) {
1533                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1534                 }
1535                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1536                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1537                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1538                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1541                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1542                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1543                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1544                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1545                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1546                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1547         }
1548         if (ndr_flags & NDR_BUFFERS) {
1549                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1550                 if (r->uptodateness_vector) {
1551                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1552                 }
1553                 if (r->partial_attribute_set) {
1554                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1555                 }
1556                 if (r->partial_attribute_set_ex) {
1557                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1558                 }
1559                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1560         }
1561         return NDR_ERR_SUCCESS;
1562 }
1563
1564 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest8(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest8 *r)
1565 {
1566         uint32_t _ptr_naming_context;
1567         TALLOC_CTX *_mem_save_naming_context_0;
1568         uint32_t _ptr_uptodateness_vector;
1569         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1570         uint32_t _ptr_partial_attribute_set;
1571         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1572         uint32_t _ptr_partial_attribute_set_ex;
1573         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1574         if (ndr_flags & NDR_SCALARS) {
1575                 NDR_CHECK(ndr_pull_align(ndr, 8));
1576                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1577                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1578                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1579                 if (_ptr_naming_context) {
1580                         NDR_PULL_ALLOC(ndr, r->naming_context);
1581                 } else {
1582                         r->naming_context = NULL;
1583                 }
1584                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1585                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1586                 if (_ptr_uptodateness_vector) {
1587                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1588                 } else {
1589                         r->uptodateness_vector = NULL;
1590                 }
1591                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1593                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1594                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1595                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1596                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1597                 if (_ptr_partial_attribute_set) {
1598                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1599                 } else {
1600                         r->partial_attribute_set = NULL;
1601                 }
1602                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1603                 if (_ptr_partial_attribute_set_ex) {
1604                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1605                 } else {
1606                         r->partial_attribute_set_ex = NULL;
1607                 }
1608                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1609                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1610         }
1611         if (ndr_flags & NDR_BUFFERS) {
1612                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1613                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1614                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1615                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1616                 if (r->uptodateness_vector) {
1617                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1618                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1619                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1620                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1621                 }
1622                 if (r->partial_attribute_set) {
1623                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1624                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1625                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1626                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1627                 }
1628                 if (r->partial_attribute_set_ex) {
1629                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1630                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1631                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1632                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1633                 }
1634                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1635         }
1636         return NDR_ERR_SUCCESS;
1637 }
1638
1639 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest8(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest8 *r)
1640 {
1641         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest8");
1642         ndr->depth++;
1643         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1644         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1645         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1646         ndr->depth++;
1647         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1648         ndr->depth--;
1649         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1650         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1651         ndr->depth++;
1652         if (r->uptodateness_vector) {
1653                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1654         }
1655         ndr->depth--;
1656         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1657         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1658         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1659         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1660         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1661         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1662         ndr->depth++;
1663         if (r->partial_attribute_set) {
1664                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1665         }
1666         ndr->depth--;
1667         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1668         ndr->depth++;
1669         if (r->partial_attribute_set_ex) {
1670                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1671         }
1672         ndr->depth--;
1673         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1674         ndr->depth--;
1675 }
1676
1677 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest10(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest10 *r)
1678 {
1679         if (ndr_flags & NDR_SCALARS) {
1680                 NDR_CHECK(ndr_push_align(ndr, 8));
1681                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1682                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1683                 if (r->naming_context == NULL) {
1684                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1685                 }
1686                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1687                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1688                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1689                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1692                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1693                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1694                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1695                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1696                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1697                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_flags));
1698                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1699         }
1700         if (ndr_flags & NDR_BUFFERS) {
1701                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1702                 if (r->uptodateness_vector) {
1703                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1704                 }
1705                 if (r->partial_attribute_set) {
1706                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1707                 }
1708                 if (r->partial_attribute_set_ex) {
1709                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1710                 }
1711                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1712         }
1713         return NDR_ERR_SUCCESS;
1714 }
1715
1716 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest10(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest10 *r)
1717 {
1718         uint32_t _ptr_naming_context;
1719         TALLOC_CTX *_mem_save_naming_context_0;
1720         uint32_t _ptr_uptodateness_vector;
1721         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1722         uint32_t _ptr_partial_attribute_set;
1723         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1724         uint32_t _ptr_partial_attribute_set_ex;
1725         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1726         if (ndr_flags & NDR_SCALARS) {
1727                 NDR_CHECK(ndr_pull_align(ndr, 8));
1728                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1729                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1730                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1731                 if (_ptr_naming_context) {
1732                         NDR_PULL_ALLOC(ndr, r->naming_context);
1733                 } else {
1734                         r->naming_context = NULL;
1735                 }
1736                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1737                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1738                 if (_ptr_uptodateness_vector) {
1739                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1740                 } else {
1741                         r->uptodateness_vector = NULL;
1742                 }
1743                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1744                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1745                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1746                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1747                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1748                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1749                 if (_ptr_partial_attribute_set) {
1750                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1751                 } else {
1752                         r->partial_attribute_set = NULL;
1753                 }
1754                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1755                 if (_ptr_partial_attribute_set_ex) {
1756                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1757                 } else {
1758                         r->partial_attribute_set_ex = NULL;
1759                 }
1760                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1761                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_flags));
1762                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1763         }
1764         if (ndr_flags & NDR_BUFFERS) {
1765                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1766                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1767                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1768                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1769                 if (r->uptodateness_vector) {
1770                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1771                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1772                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1773                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1774                 }
1775                 if (r->partial_attribute_set) {
1776                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1777                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1778                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1779                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1780                 }
1781                 if (r->partial_attribute_set_ex) {
1782                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1783                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1784                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1785                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1786                 }
1787                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1788         }
1789         return NDR_ERR_SUCCESS;
1790 }
1791
1792 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest10(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest10 *r)
1793 {
1794         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest10");
1795         ndr->depth++;
1796         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1797         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1798         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1799         ndr->depth++;
1800         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1801         ndr->depth--;
1802         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1803         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1804         ndr->depth++;
1805         if (r->uptodateness_vector) {
1806                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1807         }
1808         ndr->depth--;
1809         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1810         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1811         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1812         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1813         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1814         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1815         ndr->depth++;
1816         if (r->partial_attribute_set) {
1817                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1818         }
1819         ndr->depth--;
1820         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1821         ndr->depth++;
1822         if (r->partial_attribute_set_ex) {
1823                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1824         }
1825         ndr->depth--;
1826         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1827         ndr_print_uint32(ndr, "more_flags", r->more_flags);
1828         ndr->depth--;
1829 }
1830
1831 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesRequest *r)
1832 {
1833         if (ndr_flags & NDR_SCALARS) {
1834                 int level = ndr_push_get_switch_value(ndr, r);
1835                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
1836                 NDR_CHECK(ndr_push_union_align(ndr, 8));
1837                 switch (level) {
1838                         case 5: {
1839                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1840                         break; }
1841
1842                         case 8: {
1843                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1844                         break; }
1845
1846                         case 10: {
1847                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1848                         break; }
1849
1850                         default:
1851                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1852                 }
1853         }
1854         if (ndr_flags & NDR_BUFFERS) {
1855                 int level = ndr_push_get_switch_value(ndr, r);
1856                 switch (level) {
1857                         case 5:
1858                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1859                         break;
1860
1861                         case 8:
1862                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1863                         break;
1864
1865                         case 10:
1866                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1867                         break;
1868
1869                         default:
1870                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1871                 }
1872         }
1873         return NDR_ERR_SUCCESS;
1874 }
1875
1876 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesRequest *r)
1877 {
1878         int level;
1879         int32_t _level;
1880         level = ndr_pull_get_switch_value(ndr, r);
1881         if (ndr_flags & NDR_SCALARS) {
1882                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
1883                 if (_level != level) {
1884                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1885                 }
1886                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
1887                 switch (level) {
1888                         case 5: {
1889                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1890                         break; }
1891
1892                         case 8: {
1893                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1894                         break; }
1895
1896                         case 10: {
1897                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1898                         break; }
1899
1900                         default:
1901                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1902                 }
1903         }
1904         if (ndr_flags & NDR_BUFFERS) {
1905                 switch (level) {
1906                         case 5:
1907                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1908                         break;
1909
1910                         case 8:
1911                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1912                         break;
1913
1914                         case 10:
1915                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1916                         break;
1917
1918                         default:
1919                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1920                 }
1921         }
1922         return NDR_ERR_SUCCESS;
1923 }
1924
1925 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesRequest *r)
1926 {
1927         int level;
1928         level = ndr_print_get_switch_value(ndr, r);
1929         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesRequest");
1930         switch (level) {
1931                 case 5:
1932                         ndr_print_drsuapi_DsGetNCChangesRequest5(ndr, "req5", &r->req5);
1933                 break;
1934
1935                 case 8:
1936                         ndr_print_drsuapi_DsGetNCChangesRequest8(ndr, "req8", &r->req8);
1937                 break;
1938
1939                 case 10:
1940                         ndr_print_drsuapi_DsGetNCChangesRequest10(ndr, "req10", &r->req10);
1941                 break;
1942
1943                 default:
1944                         ndr_print_bad_level(ndr, name, level);
1945         }
1946 }
1947
1948 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2 *r)
1949 {
1950         if (ndr_flags & NDR_SCALARS) {
1951                 NDR_CHECK(ndr_push_align(ndr, 8));
1952                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1953                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
1954                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
1955                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1956         }
1957         if (ndr_flags & NDR_BUFFERS) {
1958         }
1959         return NDR_ERR_SUCCESS;
1960 }
1961
1962 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2 *r)
1963 {
1964         if (ndr_flags & NDR_SCALARS) {
1965                 NDR_CHECK(ndr_pull_align(ndr, 8));
1966                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1967                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
1968                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
1969                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1970         }
1971         if (ndr_flags & NDR_BUFFERS) {
1972         }
1973         return NDR_ERR_SUCCESS;
1974 }
1975
1976 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2 *r)
1977 {
1978         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2");
1979         ndr->depth++;
1980         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1981         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
1982         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
1983         ndr->depth--;
1984 }
1985
1986 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1987 {
1988         uint32_t cntr_cursors_0;
1989         if (ndr_flags & NDR_SCALARS) {
1990                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1991                 NDR_CHECK(ndr_push_align(ndr, 8));
1992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
1993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1994                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1995                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1996                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1997                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1998                 }
1999                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2000         }
2001         if (ndr_flags & NDR_BUFFERS) {
2002         }
2003         return NDR_ERR_SUCCESS;
2004 }
2005
2006 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2CtrEx *r)
2007 {
2008         uint32_t cntr_cursors_0;
2009         TALLOC_CTX *_mem_save_cursors_0;
2010         if (ndr_flags & NDR_SCALARS) {
2011                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
2012                 NDR_CHECK(ndr_pull_align(ndr, 8));
2013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
2015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2016                 if (r->count > 0x100000) {
2017                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2018                 }
2019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
2020                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
2021                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
2022                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
2023                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
2024                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
2025                 }
2026                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
2027                 if (r->cursors) {
2028                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
2029                 }
2030                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2031         }
2032         if (ndr_flags & NDR_BUFFERS) {
2033         }
2034         return NDR_ERR_SUCCESS;
2035 }
2036
2037 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2CtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2CtrEx *r)
2038 {
2039         uint32_t cntr_cursors_0;
2040         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2CtrEx");
2041         ndr->depth++;
2042         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
2043         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
2044         ndr_print_uint32(ndr, "count", r->count);
2045         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
2046         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
2047         ndr->depth++;
2048         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
2049                 char *idx_0=NULL;
2050                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
2051                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
2052                         free(idx_0);
2053                 }
2054         }
2055         ndr->depth--;
2056         ndr->depth--;
2057 }
2058
2059 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValue(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValue *r)
2060 {
2061         if (ndr_flags & NDR_SCALARS) {
2062                 NDR_CHECK(ndr_push_align(ndr, 5));
2063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->blob, 0)));
2064                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->blob));
2065                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2066         }
2067         if (ndr_flags & NDR_BUFFERS) {
2068                 if (r->blob) {
2069                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->blob));
2070                 }
2071         }
2072         return NDR_ERR_SUCCESS;
2073 }
2074
2075 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValue *r)
2076 {
2077         uint32_t _ptr_blob;
2078         TALLOC_CTX *_mem_save_blob_0;
2079         if (ndr_flags & NDR_SCALARS) {
2080                 NDR_CHECK(ndr_pull_align(ndr, 5));
2081                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2082                 if (r->__ndr_size > 10485760) {
2083                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2084                 }
2085                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_blob));
2086                 if (_ptr_blob) {
2087                         NDR_PULL_ALLOC(ndr, r->blob);
2088                 } else {
2089                         r->blob = NULL;
2090                 }
2091                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2092         }
2093         if (ndr_flags & NDR_BUFFERS) {
2094                 if (r->blob) {
2095                         _mem_save_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
2096                         NDR_PULL_SET_MEM_CTX(ndr, r->blob, 0);
2097                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->blob));
2098                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_blob_0, 0);
2099                 }
2100         }
2101         return NDR_ERR_SUCCESS;
2102 }
2103
2104 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValue(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValue *r)
2105 {
2106         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
2107         ndr->depth++;
2108         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_DATA_BLOB(0, r->blob, 0):r->__ndr_size);
2109         ndr_print_ptr(ndr, "blob", r->blob);
2110         ndr->depth++;
2111         if (r->blob) {
2112                 ndr_print_DATA_BLOB(ndr, "blob", *r->blob);
2113         }
2114         ndr->depth--;
2115         ndr->depth--;
2116 }
2117
2118 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValueCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValueCtr *r)
2119 {
2120         uint32_t cntr_values_1;
2121         if (ndr_flags & NDR_SCALARS) {
2122                 NDR_CHECK(ndr_push_align(ndr, 5));
2123                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
2124                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->values));
2125                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2126         }
2127         if (ndr_flags & NDR_BUFFERS) {
2128                 if (r->values) {
2129                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_values));
2130                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2131                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2132                         }
2133                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2134                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2135                         }
2136                 }
2137         }
2138         return NDR_ERR_SUCCESS;
2139 }
2140
2141 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValueCtr *r)
2142 {
2143         uint32_t _ptr_values;
2144         uint32_t cntr_values_1;
2145         TALLOC_CTX *_mem_save_values_0;
2146         TALLOC_CTX *_mem_save_values_1;
2147         if (ndr_flags & NDR_SCALARS) {
2148                 NDR_CHECK(ndr_pull_align(ndr, 5));
2149                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_values));
2150                 if (r->num_values > 10485760) {
2151                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2152                 }
2153                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_values));
2154                 if (_ptr_values) {
2155                         NDR_PULL_ALLOC(ndr, r->values);
2156                 } else {
2157                         r->values = NULL;
2158                 }
2159                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2160         }
2161         if (ndr_flags & NDR_BUFFERS) {
2162                 if (r->values) {
2163                         _mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
2164                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2165                         NDR_CHECK(ndr_pull_array_size(ndr, &r->values));
2166                         NDR_PULL_ALLOC_N(ndr, r->values, ndr_get_array_size(ndr, &r->values));
2167                         _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
2168                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2169                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2170                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2171                         }
2172                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2173                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2174                         }
2175                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
2176                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_0, 0);
2177                 }
2178                 if (r->values) {
2179                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->values, r->num_values));
2180                 }
2181         }
2182         return NDR_ERR_SUCCESS;
2183 }
2184
2185 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValueCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValueCtr *r)
2186 {
2187         uint32_t cntr_values_1;
2188         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValueCtr");
2189         ndr->depth++;
2190         ndr_print_uint32(ndr, "num_values", r->num_values);
2191         ndr_print_ptr(ndr, "values", r->values);
2192         ndr->depth++;
2193         if (r->values) {
2194                 ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->num_values);
2195                 ndr->depth++;
2196                 for (cntr_values_1=0;cntr_values_1<r->num_values;cntr_values_1++) {
2197                         char *idx_1=NULL;
2198                         if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
2199                                 ndr_print_drsuapi_DsAttributeValue(ndr, "values", &r->values[cntr_values_1]);
2200                                 free(idx_1);
2201                         }
2202                 }
2203                 ndr->depth--;
2204         }
2205         ndr->depth--;
2206         ndr->depth--;
2207 }
2208
2209 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2210 {
2211         if (ndr_flags & NDR_SCALARS) {
2212                 NDR_CHECK(ndr_push_align(ndr, 4));
2213                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
2214                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2215                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2216                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2217                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2218                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2219                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2220         }
2221         if (ndr_flags & NDR_BUFFERS) {
2222                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2223         }
2224         return NDR_ERR_SUCCESS;
2225 }
2226
2227 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3 *r)
2228 {
2229         if (ndr_flags & NDR_SCALARS) {
2230                 NDR_CHECK(ndr_pull_align(ndr, 4));
2231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2233                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2234                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2236                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2237                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2238         }
2239         if (ndr_flags & NDR_BUFFERS) {
2240                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2241         }
2242         return NDR_ERR_SUCCESS;
2243 }
2244
2245 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2246 {
2247         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3");
2248         ndr->depth++;
2249         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);
2250         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);
2251         ndr_print_GUID(ndr, "guid", &r->guid);
2252         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2253         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2254         ndr_print_string(ndr, "dn", r->dn);
2255         ndr->depth--;
2256 }
2257
2258 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3(const struct drsuapi_DsReplicaObjectIdentifier3 *r, struct smb_iconv_convenience *ic, int flags)
2259 {
2260         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3, ic);
2261 }
2262
2263 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2264 {
2265         if (ndr_flags & NDR_SCALARS) {
2266                 NDR_CHECK(ndr_push_align(ndr, 4));
2267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
2268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2269                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2270                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2271                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2272                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2273                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->binary.length + 4));
2274                 {
2275                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2276                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2277                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
2278                         ndr->flags = _flags_save_DATA_BLOB;
2279                 }
2280                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2281         }
2282         if (ndr_flags & NDR_BUFFERS) {
2283                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2284         }
2285         return NDR_ERR_SUCCESS;
2286 }
2287
2288 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2289 {
2290         if (ndr_flags & NDR_SCALARS) {
2291                 NDR_CHECK(ndr_pull_align(ndr, 4));
2292                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2293                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2294                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2295                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2297                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2298                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
2299                 {
2300                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2302                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
2303                         ndr->flags = _flags_save_DATA_BLOB;
2304                 }
2305                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2306         }
2307         if (ndr_flags & NDR_BUFFERS) {
2308                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2309         }
2310         return NDR_ERR_SUCCESS;
2311 }
2312
2313 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2314 {
2315         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3Binary");
2316         ndr->depth++;
2317         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);
2318         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);
2319         ndr_print_GUID(ndr, "guid", &r->guid);
2320         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2321         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2322         ndr_print_string(ndr, "dn", r->dn);
2323         ndr_print_uint32(ndr, "__ndr_size_binary", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->binary.length + 4:r->__ndr_size_binary);
2324         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
2325         ndr->depth--;
2326 }
2327
2328 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary(const struct drsuapi_DsReplicaObjectIdentifier3Binary *r, struct smb_iconv_convenience *ic, int flags)
2329 {
2330         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary, ic);
2331 }
2332
2333 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttribute *r)
2334 {
2335         if (ndr_flags & NDR_SCALARS) {
2336                 NDR_CHECK(ndr_push_align(ndr, 5));
2337                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2338                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2339                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2340         }
2341         if (ndr_flags & NDR_BUFFERS) {
2342                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2343         }
2344         return NDR_ERR_SUCCESS;
2345 }
2346
2347 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttribute *r)
2348 {
2349         if (ndr_flags & NDR_SCALARS) {
2350                 NDR_CHECK(ndr_pull_align(ndr, 5));
2351                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2352                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2353                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2354         }
2355         if (ndr_flags & NDR_BUFFERS) {
2356                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2357         }
2358         return NDR_ERR_SUCCESS;
2359 }
2360
2361 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttribute *r)
2362 {
2363         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttribute");
2364         ndr->depth++;
2365         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2366         ndr_print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr);
2367         ndr->depth--;
2368 }
2369
2370 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttributeCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttributeCtr *r)
2371 {
2372         uint32_t cntr_attributes_1;
2373         if (ndr_flags & NDR_SCALARS) {
2374                 NDR_CHECK(ndr_push_align(ndr, 5));
2375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2376                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
2377                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2378         }
2379         if (ndr_flags & NDR_BUFFERS) {
2380                 if (r->attributes) {
2381                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attributes));
2382                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2383                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2384                         }
2385                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2386                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2387                         }
2388                 }
2389         }
2390         return NDR_ERR_SUCCESS;
2391 }
2392
2393 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttributeCtr *r)
2394 {
2395         uint32_t _ptr_attributes;
2396         uint32_t cntr_attributes_1;
2397         TALLOC_CTX *_mem_save_attributes_0;
2398         TALLOC_CTX *_mem_save_attributes_1;
2399         if (ndr_flags & NDR_SCALARS) {
2400                 NDR_CHECK(ndr_pull_align(ndr, 5));
2401                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attributes));
2402                 if (r->num_attributes > 1048576) {
2403                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2404                 }
2405                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
2406                 if (_ptr_attributes) {
2407                         NDR_PULL_ALLOC(ndr, r->attributes);
2408                 } else {
2409                         r->attributes = NULL;
2410                 }
2411                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2412         }
2413         if (ndr_flags & NDR_BUFFERS) {
2414                 if (r->attributes) {
2415                         _mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2416                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2417                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
2418                         NDR_PULL_ALLOC_N(ndr, r->attributes, ndr_get_array_size(ndr, &r->attributes));
2419                         _mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2420                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2421                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2422                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2423                         }
2424                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2425                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2426                         }
2427                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
2428                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);
2429                 }
2430                 if (r->attributes) {
2431                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->num_attributes));
2432                 }
2433         }
2434         return NDR_ERR_SUCCESS;
2435 }
2436
2437 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttributeCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttributeCtr *r)
2438 {
2439         uint32_t cntr_attributes_1;
2440         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttributeCtr");
2441         ndr->depth++;
2442         ndr_print_uint32(ndr, "num_attributes", r->num_attributes);
2443         ndr_print_ptr(ndr, "attributes", r->attributes);
2444         ndr->depth++;
2445         if (r->attributes) {
2446                 ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->num_attributes);
2447                 ndr->depth++;
2448                 for (cntr_attributes_1=0;cntr_attributes_1<r->num_attributes;cntr_attributes_1++) {
2449                         char *idx_1=NULL;
2450                         if (asprintf(&idx_1, "[%d]", cntr_attributes_1) != -1) {
2451                                 ndr_print_drsuapi_DsReplicaAttribute(ndr, "attributes", &r->attributes[cntr_attributes_1]);
2452                                 free(idx_1);
2453                         }
2454                 }
2455                 ndr->depth--;
2456         }
2457         ndr->depth--;
2458         ndr->depth--;
2459 }
2460
2461 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2462 {
2463         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2464         return NDR_ERR_SUCCESS;
2465 }
2466
2467 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2468 {
2469         uint32_t v;
2470         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2471         *r = v;
2472         return NDR_ERR_SUCCESS;
2473 }
2474
2475 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2476 {
2477         ndr_print_uint32(ndr, name, r);
2478         ndr->depth++;
2479         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER", DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER, r);
2480         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC", DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC, r);
2481         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY", DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY, r);
2482         ndr->depth--;
2483 }
2484
2485 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObject(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObject *r)
2486 {
2487         if (ndr_flags & NDR_SCALARS) {
2488                 NDR_CHECK(ndr_push_align(ndr, 5));
2489                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2490                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, r->flags));
2491                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2492                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2493         }
2494         if (ndr_flags & NDR_BUFFERS) {
2495                 if (r->identifier) {
2496                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2497                 }
2498                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2499         }
2500         return NDR_ERR_SUCCESS;
2501 }
2502
2503 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObject *r)
2504 {
2505         uint32_t _ptr_identifier;
2506         TALLOC_CTX *_mem_save_identifier_0;
2507         if (ndr_flags & NDR_SCALARS) {
2508                 NDR_CHECK(ndr_pull_align(ndr, 5));
2509                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2510                 if (_ptr_identifier) {
2511                         NDR_PULL_ALLOC(ndr, r->identifier);
2512                 } else {
2513                         r->identifier = NULL;
2514                 }
2515                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, &r->flags));
2516                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2517                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2518         }
2519         if (ndr_flags & NDR_BUFFERS) {
2520                 if (r->identifier) {
2521                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2522                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2523                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2524                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2525                 }
2526                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2527         }
2528         return NDR_ERR_SUCCESS;
2529 }
2530
2531 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObject(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObject *r)
2532 {
2533         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObject");
2534         ndr->depth++;
2535         ndr_print_ptr(ndr, "identifier", r->identifier);
2536         ndr->depth++;
2537         if (r->identifier) {
2538                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2539         }
2540         ndr->depth--;
2541         ndr_print_drsuapi_DsReplicaObjectFlags(ndr, "flags", r->flags);
2542         ndr_print_drsuapi_DsReplicaAttributeCtr(ndr, "attribute_ctr", &r->attribute_ctr);
2543         ndr->depth--;
2544 }
2545
2546 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaData *r)
2547 {
2548         if (ndr_flags & NDR_SCALARS) {
2549                 NDR_CHECK(ndr_push_align(ndr, 8));
2550                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2551                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
2552                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2553                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
2554                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2555         }
2556         if (ndr_flags & NDR_BUFFERS) {
2557         }
2558         return NDR_ERR_SUCCESS;
2559 }
2560
2561 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaData *r)
2562 {
2563         if (ndr_flags & NDR_SCALARS) {
2564                 NDR_CHECK(ndr_pull_align(ndr, 8));
2565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2566                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
2567                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2568                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
2569                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2570         }
2571         if (ndr_flags & NDR_BUFFERS) {
2572         }
2573         return NDR_ERR_SUCCESS;
2574 }
2575
2576 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaData *r)
2577 {
2578         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaData");
2579         ndr->depth++;
2580         ndr_print_uint32(ndr, "version", r->version);
2581         ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
2582         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
2583         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
2584         ndr->depth--;
2585 }
2586
2587 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaDataCtr *r)
2588 {
2589         uint32_t cntr_meta_data_0;
2590         if (ndr_flags & NDR_SCALARS) {
2591                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
2592                 NDR_CHECK(ndr_push_align(ndr, 8));
2593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2594                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2595                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2596                 }
2597                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2598         }
2599         if (ndr_flags & NDR_BUFFERS) {
2600         }
2601         return NDR_ERR_SUCCESS;
2602 }
2603
2604 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaDataCtr *r)
2605 {
2606         uint32_t cntr_meta_data_0;
2607         TALLOC_CTX *_mem_save_meta_data_0;
2608         if (ndr_flags & NDR_SCALARS) {
2609                 NDR_CHECK(ndr_pull_array_size(ndr, &r->meta_data));
2610                 NDR_CHECK(ndr_pull_align(ndr, 8));
2611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2612                 if (r->count > 1048576) {
2613                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2614                 }
2615                 NDR_PULL_ALLOC_N(ndr, r->meta_data, ndr_get_array_size(ndr, &r->meta_data));
2616                 _mem_save_meta_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2617                 NDR_PULL_SET_MEM_CTX(ndr, r->meta_data, 0);
2618                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2619                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2620                 }
2621                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_0, 0);
2622                 if (r->meta_data) {
2623                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->meta_data, r->count));
2624                 }
2625                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2626         }
2627         if (ndr_flags & NDR_BUFFERS) {
2628         }
2629         return NDR_ERR_SUCCESS;
2630 }
2631
2632 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaDataCtr *r)
2633 {
2634         uint32_t cntr_meta_data_0;
2635         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaDataCtr");
2636         ndr->depth++;
2637         ndr_print_uint32(ndr, "count", r->count);
2638         ndr->print(ndr, "%s: ARRAY(%d)", "meta_data", (int)r->count);
2639         ndr->depth++;
2640         for (cntr_meta_data_0=0;cntr_meta_data_0<r->count;cntr_meta_data_0++) {
2641                 char *idx_0=NULL;
2642                 if (asprintf(&idx_0, "[%d]", cntr_meta_data_0) != -1) {
2643                         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data[cntr_meta_data_0]);
2644                         free(idx_0);
2645                 }
2646         }
2647         ndr->depth--;
2648         ndr->depth--;
2649 }
2650
2651 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItemEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItemEx *r)
2652 {
2653         if (ndr_flags & NDR_SCALARS) {
2654                 NDR_CHECK(ndr_push_align(ndr, 5));
2655                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
2656                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_nc_prefix));
2658                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parent_object_guid));
2659                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->meta_data_ctr));
2660                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2661         }
2662         if (ndr_flags & NDR_BUFFERS) {
2663                 if (r->next_object) {
2664                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2665                 }
2666                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2667                 if (r->parent_object_guid) {
2668                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2669                 }
2670                 if (r->meta_data_ctr) {
2671                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2672                 }
2673         }
2674         return NDR_ERR_SUCCESS;
2675 }
2676
2677 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItemEx *r)
2678 {
2679         uint32_t _ptr_next_object;
2680         TALLOC_CTX *_mem_save_next_object_0;
2681         uint32_t _ptr_parent_object_guid;
2682         TALLOC_CTX *_mem_save_parent_object_guid_0;
2683         uint32_t _ptr_meta_data_ctr;
2684         TALLOC_CTX *_mem_save_meta_data_ctr_0;
2685         if (ndr_flags & NDR_SCALARS) {
2686                 NDR_CHECK(ndr_pull_align(ndr, 5));
2687                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
2688                 if (_ptr_next_object) {
2689                         NDR_PULL_ALLOC(ndr, r->next_object);
2690                 } else {
2691                         r->next_object = NULL;
2692                 }
2693                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2694                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_nc_prefix));
2695                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parent_object_guid));
2696                 if (_ptr_parent_object_guid) {
2697                         NDR_PULL_ALLOC(ndr, r->parent_object_guid);
2698                 } else {
2699                         r->parent_object_guid = NULL;
2700                 }
2701                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_meta_data_ctr));
2702                 if (_ptr_meta_data_ctr) {
2703                         NDR_PULL_ALLOC(ndr, r->meta_data_ctr);
2704                 } else {
2705                         r->meta_data_ctr = NULL;
2706                 }
2707                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2708         }
2709         if (ndr_flags & NDR_BUFFERS) {
2710                 if (r->next_object) {
2711                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2712                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
2713                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2714                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
2715                 }
2716                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2717                 if (r->parent_object_guid) {
2718                         _mem_save_parent_object_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2719                         NDR_PULL_SET_MEM_CTX(ndr, r->parent_object_guid, 0);
2720                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2721                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_object_guid_0, 0);
2722                 }
2723                 if (r->meta_data_ctr) {
2724                         _mem_save_meta_data_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2725                         NDR_PULL_SET_MEM_CTX(ndr, r->meta_data_ctr, 0);
2726                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2727                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_ctr_0, 0);
2728                 }
2729         }
2730         return NDR_ERR_SUCCESS;
2731 }
2732
2733 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1 *r)
2734 {
2735         if (ndr_flags & NDR_SCALARS) {
2736                 NDR_CHECK(ndr_push_align(ndr, 8));
2737                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2738                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2739                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2740                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2741                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2742                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2743                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2744                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55));
2747                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2749                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2750         }
2751         if (ndr_flags & NDR_BUFFERS) {
2752                 if (r->naming_context) {
2753                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2754                 }
2755                 if (r->uptodateness_vector) {
2756                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2757                 }
2758                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2759                 if (r->first_object) {
2760                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2761                 }
2762         }
2763         return NDR_ERR_SUCCESS;
2764 }
2765
2766 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1 *r)
2767 {
2768         uint32_t _ptr_naming_context;
2769         TALLOC_CTX *_mem_save_naming_context_0;
2770         uint32_t _ptr_uptodateness_vector;
2771         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2772         uint32_t _ptr_first_object;
2773         TALLOC_CTX *_mem_save_first_object_0;
2774         if (ndr_flags & NDR_SCALARS) {
2775                 NDR_CHECK(ndr_pull_align(ndr, 8));
2776                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2777                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2778                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2779                 if (_ptr_naming_context) {
2780                         NDR_PULL_ALLOC(ndr, r->naming_context);
2781                 } else {
2782                         r->naming_context = NULL;
2783                 }
2784                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2785                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2786                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2787                 if (_ptr_uptodateness_vector) {
2788                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2789                 } else {
2790                         r->uptodateness_vector = NULL;
2791                 }
2792                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2793                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2796                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2797                 if (_ptr_first_object) {
2798                         NDR_PULL_ALLOC(ndr, r->first_object);
2799                 } else {
2800                         r->first_object = NULL;
2801                 }
2802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2803                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2804         }
2805         if (ndr_flags & NDR_BUFFERS) {
2806                 if (r->naming_context) {
2807                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2808                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2809                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2810                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2811                 }
2812                 if (r->uptodateness_vector) {
2813                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2814                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2815                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2816                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2817                 }
2818                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2819                 if (r->first_object) {
2820                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2821                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2822                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2823                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2824                 }
2825         }
2826         return NDR_ERR_SUCCESS;
2827 }
2828
2829 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1 *r)
2830 {
2831         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1");
2832         ndr->depth++;
2833         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2834         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2835         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2836         ndr->depth++;
2837         if (r->naming_context) {
2838                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2839         }
2840         ndr->depth--;
2841         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2842         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2843         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2844         ndr->depth++;
2845         if (r->uptodateness_vector) {
2846                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2847         }
2848         ndr->depth--;
2849         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2850         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2851         ndr_print_uint32(ndr, "object_count", r->object_count);
2852         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);
2853         ndr_print_ptr(ndr, "first_object", r->first_object);
2854         ndr->depth++;
2855         if (r->first_object) {
2856                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2857         }
2858         ndr->depth--;
2859         ndr_print_uint32(ndr, "more_data", r->more_data);
2860         ndr->depth--;
2861 }
2862
2863 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr1(const struct drsuapi_DsGetNCChangesCtr1 *r, struct smb_iconv_convenience *ic, int flags)
2864 {
2865         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr1, ic);
2866 }
2867
2868 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsLinkedAttributeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2869 {
2870         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2871         return NDR_ERR_SUCCESS;
2872 }
2873
2874 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsLinkedAttributeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2875 {
2876         uint32_t v;
2877         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2878         *r = v;
2879         return NDR_ERR_SUCCESS;
2880 }
2881
2882 _PUBLIC_ void ndr_print_drsuapi_DsLinkedAttributeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2883 {
2884         ndr_print_uint32(ndr, name, r);
2885         ndr->depth++;
2886         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE", DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE, r);
2887         ndr->depth--;
2888 }
2889
2890 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaLinkedAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaLinkedAttribute *r)
2891 {
2892         if (ndr_flags & NDR_SCALARS) {
2893                 NDR_CHECK(ndr_push_align(ndr, 8));
2894                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2895                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2896                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2897                 NDR_CHECK(ndr_push_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, r->flags));
2898                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_add_time));
2899                 NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2900                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2901         }
2902         if (ndr_flags & NDR_BUFFERS) {
2903                 if (r->identifier) {
2904                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2905                 }
2906                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2907         }
2908         return NDR_ERR_SUCCESS;
2909 }
2910
2911 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaLinkedAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaLinkedAttribute *r)
2912 {
2913         uint32_t _ptr_identifier;
2914         TALLOC_CTX *_mem_save_identifier_0;
2915         if (ndr_flags & NDR_SCALARS) {
2916                 NDR_CHECK(ndr_pull_align(ndr, 8));
2917                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2918                 if (_ptr_identifier) {
2919                         NDR_PULL_ALLOC(ndr, r->identifier);
2920                 } else {
2921                         r->identifier = NULL;
2922                 }
2923                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2924                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2925                 NDR_CHECK(ndr_pull_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, &r->flags));
2926                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_add_time));
2927                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2928                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2929         }
2930         if (ndr_flags & NDR_BUFFERS) {
2931                 if (r->identifier) {
2932                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2933                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2934                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2936                 }
2937                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2938         }
2939         return NDR_ERR_SUCCESS;
2940 }
2941
2942 _PUBLIC_ void ndr_print_drsuapi_DsReplicaLinkedAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaLinkedAttribute *r)
2943 {
2944         ndr_print_struct(ndr, name, "drsuapi_DsReplicaLinkedAttribute");
2945         ndr->depth++;
2946         ndr_print_ptr(ndr, "identifier", r->identifier);
2947         ndr->depth++;
2948         if (r->identifier) {
2949                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2950         }
2951         ndr->depth--;
2952         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2953         ndr_print_drsuapi_DsAttributeValue(ndr, "value", &r->value);
2954         ndr_print_drsuapi_DsLinkedAttributeFlags(ndr, "flags", r->flags);
2955         ndr_print_NTTIME_1sec(ndr, "originating_add_time", r->originating_add_time);
2956         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data);
2957         ndr->depth--;
2958 }
2959
2960 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6 *r)
2961 {
2962         uint32_t cntr_linked_attributes_1;
2963         if (ndr_flags & NDR_SCALARS) {
2964                 NDR_CHECK(ndr_push_align(ndr, 8));
2965                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2966                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2967                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2968                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2969                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2970                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2971                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2972                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2973                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55));
2975                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_object_count));
2978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_linked_attributes_count));
2979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2980                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linked_attributes));
2981                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->drs_error));
2982                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2983         }
2984         if (ndr_flags & NDR_BUFFERS) {
2985                 if (r->naming_context) {
2986                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2987                 }
2988                 if (r->uptodateness_vector) {
2989                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2990                 }
2991                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2992                 if (r->first_object) {
2993                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2994                 }
2995                 if (r->linked_attributes) {
2996                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->linked_attributes_count));
2997                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2998                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2999                         }
3000                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3001                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
3002                         }
3003                 }
3004         }
3005         return NDR_ERR_SUCCESS;
3006 }
3007
3008 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6 *r)
3009 {
3010         uint32_t _ptr_naming_context;
3011         TALLOC_CTX *_mem_save_naming_context_0;
3012         uint32_t _ptr_uptodateness_vector;
3013         TALLOC_CTX *_mem_save_uptodateness_vector_0;
3014         uint32_t _ptr_first_object;
3015         TALLOC_CTX *_mem_save_first_object_0;
3016         uint32_t _ptr_linked_attributes;
3017         uint32_t cntr_linked_attributes_1;
3018         TALLOC_CTX *_mem_save_linked_attributes_0;
3019         TALLOC_CTX *_mem_save_linked_attributes_1;
3020         if (ndr_flags & NDR_SCALARS) {
3021                 NDR_CHECK(ndr_pull_align(ndr, 8));
3022                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
3023                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
3024                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
3025                 if (_ptr_naming_context) {
3026                         NDR_PULL_ALLOC(ndr, r->naming_context);
3027                 } else {
3028                         r->naming_context = NULL;
3029                 }
3030                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
3031                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
3032                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
3033                 if (_ptr_uptodateness_vector) {
3034                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
3035                 } else {
3036                         r->uptodateness_vector = NULL;
3037                 }
3038                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
3039                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
3040                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
3041                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
3042                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
3043                 if (_ptr_first_object) {
3044                         NDR_PULL_ALLOC(ndr, r->first_object);
3045                 } else {
3046                         r->first_object = NULL;
3047                 }
3048                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
3049                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_object_count));
3050                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_linked_attributes_count));
3051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linked_attributes_count));
3052                 if (r->linked_attributes_count > 1048576) {
3053                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3054                 }
3055                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linked_attributes));
3056                 if (_ptr_linked_attributes) {
3057                         NDR_PULL_ALLOC(ndr, r->linked_attributes);
3058                 } else {
3059                         r->linked_attributes = NULL;
3060                 }
3061                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->drs_error));
3062                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
3063         }
3064         if (ndr_flags & NDR_BUFFERS) {
3065                 if (r->naming_context) {
3066                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3067                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3068                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3069                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3070                 }
3071                 if (r->uptodateness_vector) {
3072                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
3073                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
3074                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
3075                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
3076                 }
3077                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
3078                 if (r->first_object) {
3079                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
3080                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
3081                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
3082                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
3083                 }
3084                 if (r->linked_attributes) {
3085                         _mem_save_linked_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
3086                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3087                         NDR_CHECK(ndr_pull_array_size(ndr, &r->linked_attributes));
3088                         NDR_PULL_ALLOC_N(ndr, r->linked_attributes, ndr_get_array_size(ndr, &r->linked_attributes));
3089                         _mem_save_linked_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
3090                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3091                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3092                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
3093                         }
3094                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3095                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
3096                         }
3097                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_1, 0);
3098                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_0, 0);
3099                 }
3100                 if (r->linked_attributes) {
3101                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->linked_attributes, r->linked_attributes_count));
3102                 }
3103         }
3104         return NDR_ERR_SUCCESS;
3105 }
3106
3107 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6 *r)
3108 {
3109         uint32_t cntr_linked_attributes_1;
3110         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6");
3111         ndr->depth++;
3112         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
3113         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
3114         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3115         ndr->depth++;
3116         if (r->naming_context) {
3117                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3118         }
3119         ndr->depth--;
3120         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
3121         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
3122         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
3123         ndr->depth++;
3124         if (r->uptodateness_vector) {
3125                 ndr_print_drsuapi_DsReplicaCursor2CtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
3126         }
3127         ndr->depth--;
3128         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
3129         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
3130         ndr_print_uint32(ndr, "object_count", r->object_count);
3131         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);
3132         ndr_print_ptr(ndr, "first_object", r->first_object);
3133         ndr->depth++;
3134         if (r->first_object) {
3135                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
3136         }
3137         ndr->depth--;
3138         ndr_print_uint32(ndr, "more_data", r->more_data);
3139         ndr_print_uint32(ndr, "nc_object_count", r->nc_object_count);
3140         ndr_print_uint32(ndr, "nc_linked_attributes_count", r->nc_linked_attributes_count);
3141         ndr_print_uint32(ndr, "linked_attributes_count", r->linked_attributes_count);
3142         ndr_print_ptr(ndr, "linked_attributes", r->linked_attributes);
3143         ndr->depth++;
3144         if (r->linked_attributes) {
3145                 ndr->print(ndr, "%s: ARRAY(%d)", "linked_attributes", (int)r->linked_attributes_count);
3146                 ndr->depth++;
3147                 for (cntr_linked_attributes_1=0;cntr_linked_attributes_1<r->linked_attributes_count;cntr_linked_attributes_1++) {
3148                         char *idx_1=NULL;
3149                         if (asprintf(&idx_1, "[%d]", cntr_linked_attributes_1) != -1) {
3150                                 ndr_print_drsuapi_DsReplicaLinkedAttribute(ndr, "linked_attributes", &r->linked_attributes[cntr_linked_attributes_1]);
3151                                 free(idx_1);
3152                         }
3153                 }
3154                 ndr->depth--;
3155         }
3156         ndr->depth--;
3157         ndr_print_WERROR(ndr, "drs_error", r->drs_error);
3158         ndr->depth--;
3159 }
3160
3161 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr6(const struct drsuapi_DsGetNCChangesCtr6 *r, struct smb_iconv_convenience *ic, int flags)
3162 {
3163         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr6, ic);
3164 }
3165
3166 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3167 {
3168         if (ndr_flags & NDR_SCALARS) {
3169                 NDR_CHECK(ndr_push_align(ndr, 1));
3170                 {
3171                         struct ndr_push *_ndr_ctr1;
3172                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3173                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3174                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3175                 }
3176                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3177         }
3178         if (ndr_flags & NDR_BUFFERS) {
3179         }
3180         return NDR_ERR_SUCCESS;
3181 }
3182
3183 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1TS *r)
3184 {
3185         if (ndr_flags & NDR_SCALARS) {
3186                 NDR_CHECK(ndr_pull_align(ndr, 1));
3187                 {
3188                         struct ndr_pull *_ndr_ctr1;
3189                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3190                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3191                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3192                 }
3193                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3194         }
3195         if (ndr_flags & NDR_BUFFERS) {
3196         }
3197         return NDR_ERR_SUCCESS;
3198 }
3199
3200 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3201 {
3202         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1TS");
3203         ndr->depth++;
3204         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3205         ndr->depth--;
3206 }
3207
3208 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3209 {
3210         if (ndr_flags & NDR_SCALARS) {
3211                 NDR_CHECK(ndr_push_align(ndr, 1));
3212                 {
3213                         struct ndr_push *_ndr_ctr6;
3214                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3215                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3216                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3217                 }
3218                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3219         }
3220         if (ndr_flags & NDR_BUFFERS) {
3221         }
3222         return NDR_ERR_SUCCESS;
3223 }
3224
3225 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6TS *r)
3226 {
3227         if (ndr_flags & NDR_SCALARS) {
3228                 NDR_CHECK(ndr_pull_align(ndr, 1));
3229                 {
3230                         struct ndr_pull *_ndr_ctr6;
3231                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3232                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3233                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3234                 }
3235                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3236         }
3237         if (ndr_flags & NDR_BUFFERS) {
3238         }
3239         return NDR_ERR_SUCCESS;
3240 }
3241
3242 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3243 {
3244         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6TS");
3245         ndr->depth++;
3246         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3247         ndr->depth--;
3248 }
3249
3250 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3251 {
3252         uint32_t _ptr_ts;
3253         TALLOC_CTX *_mem_save_ts_0;
3254         if (ndr_flags & NDR_SCALARS) {
3255                 NDR_CHECK(ndr_pull_align(ndr, 5));
3256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3258                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3259                 if (_ptr_ts) {
3260                         NDR_PULL_ALLOC(ndr, r->ts);
3261                 } else {
3262                         r->ts = NULL;
3263                 }
3264                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3265         }
3266         if (ndr_flags & NDR_BUFFERS) {
3267                 if (r->ts) {
3268                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3269                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3270                         {
3271                                 struct ndr_pull *_ndr_ts;
3272                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3273                                 {
3274                                         struct ndr_pull *_ndr_ts_compressed;
3275                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3276                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3277                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3278                                 }
3279                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3280                         }
3281                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3282                 }
3283         }
3284         return NDR_ERR_SUCCESS;
3285 }
3286
3287 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3288 {
3289         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr1");
3290         ndr->depth++;
3291         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3292         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3293         ndr_print_ptr(ndr, "ts", r->ts);
3294         ndr->depth++;
3295         if (r->ts) {
3296                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3297         }
3298         ndr->depth--;
3299         ndr->depth--;
3300 }
3301
3302 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3303 {
3304         uint32_t _ptr_ts;
3305         TALLOC_CTX *_mem_save_ts_0;
3306         if (ndr_flags & NDR_SCALARS) {
3307                 NDR_CHECK(ndr_pull_align(ndr, 5));
3308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3310                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3311                 if (_ptr_ts) {
3312                         NDR_PULL_ALLOC(ndr, r->ts);
3313                 } else {
3314                         r->ts = NULL;
3315                 }
3316                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3317         }
3318         if (ndr_flags & NDR_BUFFERS) {
3319                 if (r->ts) {
3320                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3321                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3322                         {
3323                                 struct ndr_pull *_ndr_ts;
3324                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3325                                 {
3326                                         struct ndr_pull *_ndr_ts_compressed;
3327                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3328                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3329                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3330                                 }
3331                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3332                         }
3333                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3334                 }
3335         }
3336         return NDR_ERR_SUCCESS;
3337 }
3338
3339 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3340 {
3341         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr6");
3342         ndr->depth++;
3343         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3344         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3345         ndr_print_ptr(ndr, "ts", r->ts);
3346         ndr->depth++;
3347         if (r->ts) {
3348                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3349         }
3350         ndr->depth--;
3351         ndr->depth--;
3352 }
3353
3354 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3355 {
3356         uint32_t _ptr_ts;
3357         TALLOC_CTX *_mem_save_ts_0;
3358         if (ndr_flags & NDR_SCALARS) {
3359                 NDR_CHECK(ndr_pull_align(ndr, 5));
3360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3362                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3363                 if (_ptr_ts) {
3364                         NDR_PULL_ALLOC(ndr, r->ts);
3365                 } else {
3366                         r->ts = NULL;
3367                 }
3368                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3369         }
3370         if (ndr_flags & NDR_BUFFERS) {
3371                 if (r->ts) {
3372                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3373                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3374                         {
3375                                 struct ndr_pull *_ndr_ts;
3376                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3377                                 {
3378                                         struct ndr_pull *_ndr_ts_compressed;
3379                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3380                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3381                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3382                                 }
3383                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3384                         }
3385                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3386                 }
3387         }
3388         return NDR_ERR_SUCCESS;
3389 }
3390
3391 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3392 {
3393         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr1");
3394         ndr->depth++;
3395         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3396         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3397         ndr_print_ptr(ndr, "ts", r->ts);
3398         ndr->depth++;
3399         if (r->ts) {
3400                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3401         }
3402         ndr->depth--;
3403         ndr->depth--;
3404 }
3405
3406 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3407 {
3408         uint32_t _ptr_ts;
3409         TALLOC_CTX *_mem_save_ts_0;
3410         if (ndr_flags & NDR_SCALARS) {
3411                 NDR_CHECK(ndr_pull_align(ndr, 5));
3412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3414                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3415                 if (_ptr_ts) {
3416                         NDR_PULL_ALLOC(ndr, r->ts);
3417                 } else {
3418                         r->ts = NULL;
3419                 }
3420                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3421         }
3422         if (ndr_flags & NDR_BUFFERS) {
3423                 if (r->ts) {
3424                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3425                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3426                         {
3427                                 struct ndr_pull *_ndr_ts;
3428                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3429                                 {
3430                                         struct ndr_pull *_ndr_ts_compressed;
3431                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3432                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3433                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3434                                 }
3435                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3436                         }
3437                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3438                 }
3439         }
3440         return NDR_ERR_SUCCESS;
3441 }
3442
3443 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3444 {
3445         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr6");
3446         ndr->depth++;
3447         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3448         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3449         ndr_print_ptr(ndr, "ts", r->ts);
3450         ndr->depth++;
3451         if (r->ts) {
3452                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3453         }
3454         ndr->depth--;
3455         ndr->depth--;
3456 }
3457
3458 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressionType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType r)
3459 {
3460         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
3461         return NDR_ERR_SUCCESS;
3462 }
3463
3464 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressionType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType *r)
3465 {
3466         uint16_t v;
3467         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
3468         *r = v;
3469         return NDR_ERR_SUCCESS;
3470 }
3471
3472 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressionType(struct ndr_print *ndr, const char *name, enum drsuapi_DsGetNCChangesCompressionType r)
3473 {
3474         const char *val = NULL;
3475
3476         switch (r) {
3477                 case DRSUAPI_COMPRESSION_TYPE_MSZIP: val = "DRSUAPI_COMPRESSION_TYPE_MSZIP"; break;
3478                 case DRSUAPI_COMPRESSION_TYPE_XPRESS: val = "DRSUAPI_COMPRESSION_TYPE_XPRESS"; break;
3479         }
3480         ndr_print_enum(ndr, name, "ENUM", val, r);
3481 }
3482
3483 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3484 {
3485         {
3486                 uint32_t _flags_save_UNION = ndr->flags;
3487                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3488                 if (ndr_flags & NDR_SCALARS) {
3489                         int level = ndr_push_get_switch_value(ndr, r);
3490                         NDR_CHECK(ndr_push_union_align(ndr, 5));
3491                         switch (level) {
3492                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3493                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3494                                 break; }
3495
3496                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3497                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3498                                 break; }
3499
3500                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3501                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3502                                 break; }
3503
3504                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3505                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3506                                 break; }
3507
3508                                 default:
3509                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3510                         }
3511                 }
3512                 if (ndr_flags & NDR_BUFFERS) {
3513                         int level = ndr_push_get_switch_value(ndr, r);
3514                         switch (level) {
3515                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3516                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3517                                 break;
3518
3519                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3520                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3521                                 break;
3522
3523                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3524                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3525                                 break;
3526
3527                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3528                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3529                                 break;
3530
3531                                 default:
3532                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3533                         }
3534                 }
3535                 ndr->flags = _flags_save_UNION;
3536         }
3537         return NDR_ERR_SUCCESS;
3538 }
3539
3540 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCompressedCtr *r)
3541 {
3542         int level;
3543         {
3544                 uint32_t _flags_save_UNION = ndr->flags;
3545                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3546                 level = ndr_pull_get_switch_value(ndr, r);
3547                 if (ndr_flags & NDR_SCALARS) {
3548                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
3549                         switch (level) {
3550                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3551                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3552                                 break; }
3553
3554                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3555                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3556                                 break; }
3557
3558                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3559                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3560                                 break; }
3561
3562                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3563                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3564                                 break; }
3565
3566                                 default:
3567                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3568                         }
3569                 }
3570                 if (ndr_flags & NDR_BUFFERS) {
3571                         switch (level) {
3572                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3573                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3574                                 break;
3575
3576                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3577                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3578                                 break;
3579
3580                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3581                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3582                                 break;
3583
3584                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3585                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3586                                 break;
3587
3588                                 default:
3589                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3590                         }
3591                 }
3592                 ndr->flags = _flags_save_UNION;
3593         }
3594         return NDR_ERR_SUCCESS;
3595 }
3596
3597 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3598 {
3599         int level;
3600         {
3601                 uint32_t _flags_save_UNION = ndr->flags;
3602                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3603                 level = ndr_print_get_switch_value(ndr, r);
3604                 ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCompressedCtr");
3605                 switch (level) {
3606                         case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3607                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3608                         break;
3609
3610                         case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3611                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, "mszip6", &r->mszip6);
3612                         break;
3613
3614                         case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3615                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, "xpress1", &r->xpress1);
3616                         break;
3617
3618                         case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3619                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, "xpress6", &r->xpress6);
3620                         break;
3621
3622                         default:
3623                                 ndr_print_bad_level(ndr, name, level);
3624                 }
3625                 ndr->flags = _flags_save_UNION;
3626         }
3627 }
3628
3629 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr2 *r)
3630 {
3631         if (ndr_flags & NDR_SCALARS) {
3632                 NDR_CHECK(ndr_push_align(ndr, 5));
3633                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3634                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3635         }
3636         if (ndr_flags & NDR_BUFFERS) {
3637                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3638         }
3639         return NDR_ERR_SUCCESS;
3640 }
3641
3642 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr2 *r)
3643 {
3644         if (ndr_flags & NDR_SCALARS) {
3645                 NDR_CHECK(ndr_pull_align(ndr, 5));
3646                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3647                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3648         }
3649         if (ndr_flags & NDR_BUFFERS) {
3650                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3651         }
3652         return NDR_ERR_SUCCESS;
3653 }
3654
3655 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr2 *r)
3656 {
3657         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr2");
3658         ndr->depth++;
3659         ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3660         ndr->depth--;
3661 }
3662
3663 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr7 *r)
3664 {
3665         if (ndr_flags & NDR_SCALARS) {
3666                 NDR_CHECK(ndr_push_align(ndr, 5));
3667                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
3668                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, r->type));
3669                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3670                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3671                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3672         }
3673         if (ndr_flags & NDR_BUFFERS) {
3674                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3675         }
3676         return NDR_ERR_SUCCESS;
3677 }
3678
3679 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr7 *r)
3680 {
3681         if (ndr_flags & NDR_SCALARS) {
3682                 NDR_CHECK(ndr_pull_align(ndr, 5));
3683                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
3684                 if (r->level < 0 || r->level > 6) {
3685                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3686                 }
3687                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, &r->type));
3688                 if (r->type < 2 || r->type > 3) {
3689                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3690                 }
3691                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3692                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3693                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3694         }
3695         if (ndr_flags & NDR_BUFFERS) {
3696                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3697         }
3698         return NDR_ERR_SUCCESS;
3699 }
3700
3701 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr7(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr7 *r)
3702 {
3703         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr7");
3704         ndr->depth++;
3705         ndr_print_int32(ndr, "level", r->level);
3706         ndr_print_drsuapi_DsGetNCChangesCompressionType(ndr, "type", r->type);
3707         ndr_print_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16));
3708         ndr_print_drsuapi_DsGetNCChangesCompressedCtr(ndr, "ctr", &r->ctr);
3709         ndr->depth--;
3710 }
3711
3712 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCtr *r)
3713 {
3714         if (ndr_flags & NDR_SCALARS) {
3715                 int level = ndr_push_get_switch_value(ndr, r);
3716                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3717                 NDR_CHECK(ndr_push_union_align(ndr, 8));
3718                 switch (level) {
3719                         case 1: {
3720                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3721                         break; }
3722
3723                         case 2: {
3724                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3725                         break; }
3726
3727                         case 6: {
3728                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3729                         break; }
3730
3731                         case 7: {
3732                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3733                         break; }
3734
3735                         default:
3736                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3737                 }
3738         }
3739         if (ndr_flags & NDR_BUFFERS) {
3740                 int level = ndr_push_get_switch_value(ndr, r);
3741                 switch (level) {
3742                         case 1:
3743                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3744                         break;
3745
3746                         case 2:
3747                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3748                         break;
3749
3750                         case 6:
3751                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3752                         break;
3753
3754                         case 7:
3755                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3756                         break;
3757
3758                         default:
3759                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3760                 }
3761         }
3762         return NDR_ERR_SUCCESS;
3763 }
3764
3765 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCtr *r)
3766 {
3767         int level;
3768         int32_t _level;
3769         level = ndr_pull_get_switch_value(ndr, r);
3770         if (ndr_flags & NDR_SCALARS) {
3771                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3772                 if (_level != level) {
3773                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3774                 }
3775                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
3776                 switch (level) {
3777                         case 1: {
3778                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3779                         break; }
3780
3781                         case 2: {
3782                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3783                         break; }
3784
3785                         case 6: {
3786                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3787                         break; }
3788
3789                         case 7: {
3790                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3791                         break; }
3792
3793                         default:
3794                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3795                 }
3796         }
3797         if (ndr_flags & NDR_BUFFERS) {
3798                 switch (level) {
3799                         case 1:
3800                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3801                         break;
3802
3803                         case 2:
3804                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3805                         break;
3806
3807                         case 6:
3808                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3809                         break;
3810
3811                         case 7:
3812                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3813                         break;
3814
3815                         default:
3816                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3817                 }
3818         }
3819         return NDR_ERR_SUCCESS;
3820 }
3821
3822 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCtr *r)
3823 {
3824         int level;
3825         level = ndr_print_get_switch_value(ndr, r);
3826         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCtr");
3827         switch (level) {
3828                 case 1:
3829                         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3830                 break;
3831
3832                 case 2:
3833                         ndr_print_drsuapi_DsGetNCChangesCtr2(ndr, "ctr2", &r->ctr2);
3834                 break;
3835
3836                 case 6:
3837                         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3838                 break;
3839
3840                 case 7:
3841                         ndr_print_drsuapi_DsGetNCChangesCtr7(ndr, "ctr7", &r->ctr7);
3842                 break;
3843
3844                 default:
3845                         ndr_print_bad_level(ndr, name, level);
3846         }
3847 }
3848
3849 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3850 {
3851         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3852         return NDR_ERR_SUCCESS;
3853 }
3854
3855 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3856 {
3857         uint32_t v;
3858         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3859         *r = v;
3860         return NDR_ERR_SUCCESS;
3861 }
3862
3863 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3864 {
3865         ndr_print_uint32(ndr, name, r);
3866         ndr->depth++;
3867         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION, r);
3868         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_GETCHG_CHECK", DRSUAPI_DS_REPLICA_UPDATE_GETCHG_CHECK, r);
3869         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE, r);
3870         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE, r);
3871         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE", DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE, r);
3872         ndr->depth--;
3873 }
3874
3875 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3876 {
3877         if (ndr_flags & NDR_SCALARS) {
3878                 NDR_CHECK(ndr_push_align(ndr, 5));
3879                 if (r->naming_context == NULL) {
3880                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3881                 }
3882                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3883                 if (r->dest_dsa_dns_name == NULL) {
3884                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3885                 }
3886                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3887                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3888                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->options));
3889                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3890         }
3891         if (ndr_flags & NDR_BUFFERS) {
3892                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3893                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3894                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3895                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3896                 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));
3897         }
3898         return NDR_ERR_SUCCESS;
3899 }
3900
3901 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3902 {
3903         uint32_t _ptr_naming_context;
3904         TALLOC_CTX *_mem_save_naming_context_0;
3905         uint32_t _ptr_dest_dsa_dns_name;
3906         if (ndr_flags & NDR_SCALARS) {
3907                 NDR_CHECK(ndr_pull_align(ndr, 5));
3908                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3909                 if (_ptr_naming_context) {
3910                         NDR_PULL_ALLOC(ndr, r->naming_context);
3911                 } else {
3912                         r->naming_context = NULL;
3913                 }
3914                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_dest_dsa_dns_name));
3915                 if (_ptr_dest_dsa_dns_name) {
3916                         NDR_PULL_ALLOC(ndr, r->dest_dsa_dns_name);
3917                 } else {
3918                         r->dest_dsa_dns_name = NULL;
3919                 }
3920                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3921                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->options));
3922                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3923         }
3924         if (ndr_flags & NDR_BUFFERS) {
3925                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3926                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3927                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3928                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3929                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
3930                 NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
3931                 if (ndr_get_array_length(ndr, &r->dest_dsa_dns_name) > ndr_get_array_size(ndr, &r->dest_dsa_dns_name)) {
3932                         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));
3933                 }
3934                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t)));
3935                 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));
3936         }
3937         return NDR_ERR_SUCCESS;
3938 }
3939
3940 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3941 {
3942         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefsRequest1");
3943         ndr->depth++;
3944         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3945         ndr->depth++;
3946         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3947         ndr->depth--;
3948         ndr_print_ptr(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3949         ndr->depth++;
3950         ndr_print_string(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3951         ndr->depth--;
3952         ndr_print_GUID(ndr, "dest_dsa_guid", &r->dest_dsa_guid);
3953         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "options", r->options);
3954         ndr->depth--;
3955 }
3956
3957 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3958 {
3959         if (ndr_flags & NDR_SCALARS) {
3960                 int level = ndr_push_get_switch_value(ndr, r);
3961                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3962                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3963                 switch (level) {
3964                         case 1: {
3965                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3966                         break; }
3967
3968                         default:
3969                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3970                 }
3971         }
3972         if (ndr_flags & NDR_BUFFERS) {
3973                 int level = ndr_push_get_switch_value(ndr, r);
3974                 switch (level) {
3975                         case 1:
3976                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3977                         break;
3978
3979                         default:
3980                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3981                 }
3982         }
3983         return NDR_ERR_SUCCESS;
3984 }
3985
3986 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaUpdateRefsRequest *r)
3987 {
3988         int level;
3989         int32_t _level;
3990         level = ndr_pull_get_switch_value(ndr, r);
3991         if (ndr_flags & NDR_SCALARS) {
3992                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3993                 if (_level != level) {
3994                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3995                 }
3996                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3997                 switch (level) {
3998                         case 1: {
3999                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
4000                         break; }
4001
4002                         default:
4003                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4004                 }
4005         }
4006         if (ndr_flags & NDR_BUFFERS) {
4007                 switch (level) {
4008                         case 1:
4009                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
4010                         break;
4011
4012                         default:
4013                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4014                 }
4015         }
4016         return NDR_ERR_SUCCESS;
4017 }
4018
4019 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r)
4020 {
4021         int level;
4022         level = ndr_print_get_switch_value(ndr, r);
4023         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaUpdateRefsRequest");
4024         switch (level) {
4025                 case 1:
4026                         ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(ndr, "req1", &r->req1);
4027                 break;
4028
4029                 default:
4030                         ndr_print_bad_level(ndr, name, level);
4031         }
4032 }
4033
4034 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4035 {
4036         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4037         return NDR_ERR_SUCCESS;
4038 }
4039
4040 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4041 {
4042         uint32_t v;
4043         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4044         *r = v;
4045         return NDR_ERR_SUCCESS;
4046 }
4047
4048 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddOptions(struct ndr_print *ndr, const char *name, uint32_t r)
4049 {
4050         ndr_print_uint32(ndr, name, r);
4051         ndr->depth++;
4052         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
4053         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
4054         ndr->depth--;
4055 }
4056
4057 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest1 *r)
4058 {
4059         if (ndr_flags & NDR_SCALARS) {
4060                 NDR_CHECK(ndr_push_align(ndr, 5));
4061                 if (r->naming_context == NULL) {
4062                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4063                 }
4064                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4065                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4066                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4067                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->options));
4068                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4069         }
4070         if (ndr_flags & NDR_BUFFERS) {
4071                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4072                 if (r->source_dsa_address) {
4073                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4074                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4075                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4076                         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));
4077                 }
4078         }
4079         return NDR_ERR_SUCCESS;
4080 }
4081
4082 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest1 *r)
4083 {
4084         uint32_t _ptr_naming_context;
4085         TALLOC_CTX *_mem_save_naming_context_0;
4086         uint32_t _ptr_source_dsa_address;
4087         TALLOC_CTX *_mem_save_source_dsa_address_0;
4088         if (ndr_flags & NDR_SCALARS) {
4089                 NDR_CHECK(ndr_pull_align(ndr, 5));
4090                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4091                 if (_ptr_naming_context) {
4092                         NDR_PULL_ALLOC(ndr, r->naming_context);
4093                 } else {
4094                         r->naming_context = NULL;
4095                 }
4096                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4097                 if (_ptr_source_dsa_address) {
4098                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4099                 } else {
4100                         r->source_dsa_address = NULL;
4101                 }
4102                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4103                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options));
4104                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4105         }
4106         if (ndr_flags & NDR_BUFFERS) {
4107                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4108                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4109                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4110                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4111                 if (r->source_dsa_address) {
4112                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4113                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4114                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4115                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4116                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4117                                 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));
4118                         }
4119                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4120                         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));
4121                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4122                 }
4123         }
4124         return NDR_ERR_SUCCESS;
4125 }
4126
4127 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest1 *r)
4128 {
4129         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest1");
4130         ndr->depth++;
4131         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4132         ndr->depth++;
4133         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4134         ndr->depth--;
4135         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4136         ndr->depth++;
4137         if (r->source_dsa_address) {
4138                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4139         }
4140         ndr->depth--;
4141         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4142         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "options", r->options);
4143         ndr->depth--;
4144 }
4145
4146 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest2 *r)
4147 {
4148         if (ndr_flags & NDR_SCALARS) {
4149                 NDR_CHECK(ndr_push_align(ndr, 5));
4150                 if (r->naming_context == NULL) {
4151                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4152                 }
4153                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4154                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_dn));
4155                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_dn));
4156                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4157                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4158                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->options));
4159                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4160         }
4161         if (ndr_flags & NDR_BUFFERS) {
4162                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4163                 if (r->source_dsa_dn) {
4164                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4165                 }
4166                 if (r->transport_dn) {
4167                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4168                 }
4169                 if (r->source_dsa_address) {
4170                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4171                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4172                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4173                         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));
4174                 }
4175         }
4176         return NDR_ERR_SUCCESS;
4177 }
4178
4179 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest2 *r)
4180 {
4181         uint32_t _ptr_naming_context;
4182         TALLOC_CTX *_mem_save_naming_context_0;
4183         uint32_t _ptr_source_dsa_dn;
4184         TALLOC_CTX *_mem_save_source_dsa_dn_0;
4185         uint32_t _ptr_transport_dn;
4186         TALLOC_CTX *_mem_save_transport_dn_0;
4187         uint32_t _ptr_source_dsa_address;
4188         TALLOC_CTX *_mem_save_source_dsa_address_0;
4189         if (ndr_flags & NDR_SCALARS) {
4190                 NDR_CHECK(ndr_pull_align(ndr, 5));
4191                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4192                 if (_ptr_naming_context) {
4193                         NDR_PULL_ALLOC(ndr, r->naming_context);
4194                 } else {
4195                         r->naming_context = NULL;
4196                 }
4197                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_dn));
4198                 if (_ptr_source_dsa_dn) {
4199                         NDR_PULL_ALLOC(ndr, r->source_dsa_dn);
4200                 } else {
4201                         r->source_dsa_dn = NULL;
4202                 }
4203                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_dn));
4204                 if (_ptr_transport_dn) {
4205                         NDR_PULL_ALLOC(ndr, r->transport_dn);
4206                 } else {
4207                         r->transport_dn = NULL;
4208                 }
4209                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4210                 if (_ptr_source_dsa_address) {
4211                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4212                 } else {
4213                         r->source_dsa_address = NULL;
4214                 }
4215                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4216                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options));
4217                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4218         }
4219         if (ndr_flags & NDR_BUFFERS) {
4220                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4221                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4222                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4223                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4224                 if (r->source_dsa_dn) {
4225                         _mem_save_source_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4226                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_dn, 0);
4227                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4228                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_dn_0, 0);
4229                 }
4230                 if (r->transport_dn) {
4231                         _mem_save_transport_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4232                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_dn, 0);
4233                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4234                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_dn_0, 0);
4235                 }
4236                 if (r->source_dsa_address) {
4237                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4238                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4239                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4240                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4241                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4242                                 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));
4243                         }
4244                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4245                         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));
4246                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4247                 }
4248         }
4249         return NDR_ERR_SUCCESS;
4250 }
4251
4252 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest2 *r)
4253 {
4254         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest2");
4255         ndr->depth++;
4256         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4257         ndr->depth++;
4258         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4259         ndr->depth--;
4260         ndr_print_ptr(ndr, "source_dsa_dn", r->source_dsa_dn);
4261         ndr->depth++;
4262         if (r->source_dsa_dn) {
4263                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "source_dsa_dn", r->source_dsa_dn);
4264         }
4265         ndr->depth--;
4266         ndr_print_ptr(ndr, "transport_dn", r->transport_dn);
4267         ndr->depth++;
4268         if (r->transport_dn) {
4269                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "transport_dn", r->transport_dn);
4270         }
4271         ndr->depth--;
4272         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4273         ndr->depth++;
4274         if (r->source_dsa_address) {
4275                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4276         }
4277         ndr->depth--;
4278         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4279         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "options", r->options);
4280         ndr->depth--;
4281 }
4282
4283 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaAddRequest *r)
4284 {
4285         if (ndr_flags & NDR_SCALARS) {
4286                 int level = ndr_push_get_switch_value(ndr, r);
4287                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4288                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4289                 switch (level) {
4290                         case 1: {
4291                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4292                         break; }
4293
4294                         case 2: {
4295                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4296                         break; }
4297
4298                         default:
4299                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4300                 }
4301         }
4302         if (ndr_flags & NDR_BUFFERS) {
4303                 int level = ndr_push_get_switch_value(ndr, r);
4304                 switch (level) {
4305                         case 1:
4306                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4307                         break;
4308
4309                         case 2:
4310                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4311                         break;
4312
4313                         default:
4314                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4315                 }
4316         }
4317         return NDR_ERR_SUCCESS;
4318 }
4319
4320 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaAddRequest *r)
4321 {
4322         int level;
4323         int32_t _level;
4324         level = ndr_pull_get_switch_value(ndr, r);
4325         if (ndr_flags & NDR_SCALARS) {
4326                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4327                 if (_level != level) {
4328                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4329                 }
4330                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4331                 switch (level) {
4332                         case 1: {
4333                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4334                         break; }
4335
4336                         case 2: {
4337                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4338                         break; }
4339
4340                         default:
4341                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4342                 }
4343         }
4344         if (ndr_flags & NDR_BUFFERS) {
4345                 switch (level) {
4346                         case 1:
4347                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4348                         break;
4349
4350                         case 2:
4351                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4352                         break;
4353
4354                         default:
4355                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4356                 }
4357         }
4358         return NDR_ERR_SUCCESS;
4359 }
4360
4361 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaAddRequest *r)
4362 {
4363         int level;
4364         level = ndr_print_get_switch_value(ndr, r);
4365         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaAddRequest");
4366         switch (level) {
4367                 case 1:
4368                         ndr_print_drsuapi_DsReplicaAddRequest1(ndr, "req1", &r->req1);
4369                 break;
4370
4371                 case 2:
4372                         ndr_print_drsuapi_DsReplicaAddRequest2(ndr, "req2", &r->req2);
4373                 break;
4374
4375                 default:
4376                         ndr_print_bad_level(ndr, name, level);
4377         }
4378 }
4379
4380 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDeleteOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4381 {
4382         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4383         return NDR_ERR_SUCCESS;
4384 }
4385
4386 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDeleteOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4387 {
4388         uint32_t v;
4389         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4390         *r = v;
4391         return NDR_ERR_SUCCESS;
4392 }
4393
4394 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDeleteOptions(struct ndr_print *ndr, const char *name, uint32_t r)
4395 {
4396         ndr_print_uint32(ndr, name, r);
4397         ndr->depth++;
4398         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
4399         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
4400         ndr->depth--;
4401 }
4402
4403 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaDelRequest1 *r)
4404 {
4405         if (ndr_flags & NDR_SCALARS) {
4406                 NDR_CHECK(ndr_push_align(ndr, 5));
4407                 if (r->naming_context == NULL) {
4408                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4409                 }
4410                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4411                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4412                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->options));
4413                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4414         }
4415         if (ndr_flags & NDR_BUFFERS) {
4416                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4417                 if (r->source_dsa_address) {
4418                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4419                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4420                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4421                         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));
4422                 }
4423         }
4424         return NDR_ERR_SUCCESS;
4425 }
4426
4427 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaDelRequest1 *r)
4428 {
4429         uint32_t _ptr_naming_context;
4430         TALLOC_CTX *_mem_save_naming_context_0;
4431         uint32_t _ptr_source_dsa_address;
4432         TALLOC_CTX *_mem_save_source_dsa_address_0;
4433         if (ndr_flags & NDR_SCALARS) {
4434                 NDR_CHECK(ndr_pull_align(ndr, 5));
4435                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4436                 if (_ptr_naming_context) {
4437                         NDR_PULL_ALLOC(ndr, r->naming_context);
4438                 } else {
4439                         r->naming_context = NULL;
4440                 }
4441                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4442                 if (_ptr_source_dsa_address) {
4443                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4444                 } else {
4445                         r->source_dsa_address = NULL;
4446                 }
4447                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->options));
4448                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4449         }
4450         if (ndr_flags & NDR_BUFFERS) {
4451                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4452                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4453                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4454                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4455                 if (r->source_dsa_address) {
4456                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4457                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4458                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4459                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4460                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4461                                 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));
4462                         }
4463                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4464                         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));
4465                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4466                 }
4467         }
4468         return NDR_ERR_SUCCESS;
4469 }
4470
4471 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaDelRequest1 *r)
4472 {
4473         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDelRequest1");
4474         ndr->depth++;
4475         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4476         ndr->depth++;
4477         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4478         ndr->depth--;
4479         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4480         ndr->depth++;
4481         if (r->source_dsa_address) {
4482                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4483         }
4484         ndr->depth--;
4485         ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "options", r->options);
4486         ndr->depth--;
4487 }
4488
4489 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaDelRequest *r)
4490 {
4491         if (ndr_flags & NDR_SCALARS) {
4492                 int level = ndr_push_get_switch_value(ndr, r);
4493                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4494                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4495                 switch (level) {
4496                         case 1: {
4497                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4498                         break; }
4499
4500                         default:
4501                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4502                 }
4503         }
4504         if (ndr_flags & NDR_BUFFERS) {
4505                 int level = ndr_push_get_switch_value(ndr, r);
4506                 switch (level) {
4507                         case 1:
4508                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4509                         break;
4510
4511                         default:
4512                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4513                 }
4514         }
4515         return NDR_ERR_SUCCESS;
4516 }
4517
4518 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaDelRequest *r)
4519 {
4520         int level;
4521         int32_t _level;
4522         level = ndr_pull_get_switch_value(ndr, r);
4523         if (ndr_flags & NDR_SCALARS) {
4524                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4525                 if (_level != level) {
4526                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4527                 }
4528                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4529                 switch (level) {
4530                         case 1: {
4531                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4532                         break; }
4533
4534                         default:
4535                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4536                 }
4537         }
4538         if (ndr_flags & NDR_BUFFERS) {
4539                 switch (level) {
4540                         case 1:
4541                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4542                         break;
4543
4544                         default:
4545                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4546                 }
4547         }
4548         return NDR_ERR_SUCCESS;
4549 }
4550
4551 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaDelRequest *r)
4552 {
4553         int level;
4554         level = ndr_print_get_switch_value(ndr, r);
4555         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaDelRequest");
4556         switch (level) {
4557                 case 1:
4558                         ndr_print_drsuapi_DsReplicaDelRequest1(ndr, "req1", &r->req1);
4559                 break;
4560
4561                 default:
4562                         ndr_print_bad_level(ndr, name, level);
4563         }
4564 }
4565
4566 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModifyOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4567 {
4568         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4569         return NDR_ERR_SUCCESS;
4570 }
4571
4572 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModifyOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4573 {
4574         uint32_t v;
4575         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4576         *r = v;
4577         return NDR_ERR_SUCCESS;
4578 }
4579
4580 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModifyOptions(struct ndr_print *ndr, const char *name, uint32_t r)
4581 {
4582         ndr_print_uint32(ndr, name, r);
4583         ndr->depth++;
4584         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
4585         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
4586         ndr->depth--;
4587 }
4588
4589 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaModRequest1 *r)
4590 {
4591         if (ndr_flags & NDR_SCALARS) {
4592                 NDR_CHECK(ndr_push_align(ndr, 5));
4593                 if (r->naming_context == NULL) {
4594                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4595                 }
4596                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4597                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dra));
4598                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dra_address));
4599                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->replica_flags));
4601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->modify_fields));
4602                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->options));
4603                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4604         }
4605         if (ndr_flags & NDR_BUFFERS) {
4606                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4607                 if (r->source_dra_address) {
4608                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4609                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4610                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4611                         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));
4612                 }
4613         }
4614         return NDR_ERR_SUCCESS;
4615 }
4616
4617 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaModRequest1 *r)
4618 {
4619         uint32_t _ptr_naming_context;
4620         TALLOC_CTX *_mem_save_naming_context_0;
4621         uint32_t _ptr_source_dra_address;
4622         TALLOC_CTX *_mem_save_source_dra_address_0;
4623         if (ndr_flags & NDR_SCALARS) {
4624                 NDR_CHECK(ndr_pull_align(ndr, 5));
4625                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4626                 if (_ptr_naming_context) {
4627                         NDR_PULL_ALLOC(ndr, r->naming_context);
4628                 } else {
4629                         r->naming_context = NULL;
4630                 }
4631                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dra));
4632                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dra_address));
4633                 if (_ptr_source_dra_address) {
4634                         NDR_PULL_ALLOC(ndr, r->source_dra_address);
4635                 } else {
4636                         r->source_dra_address = NULL;
4637                 }
4638                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4639                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->replica_flags));
4640                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->modify_fields));
4641                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->options));
4642                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4643         }
4644         if (ndr_flags & NDR_BUFFERS) {
4645                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4646                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4647                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4648                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4649                 if (r->source_dra_address) {
4650                         _mem_save_source_dra_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4651                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dra_address, 0);
4652                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dra_address));
4653                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dra_address));
4654                         if (ndr_get_array_length(ndr, &r->source_dra_address) > ndr_get_array_size(ndr, &r->source_dra_address)) {
4655                                 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));
4656                         }
4657                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t)));
4658                         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));
4659                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dra_address_0, 0);
4660                 }
4661         }
4662         return NDR_ERR_SUCCESS;
4663 }
4664
4665 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaModRequest1 *r)
4666 {
4667         ndr_print_struct(ndr, name, "drsuapi_DsReplicaModRequest1");
4668         ndr->depth++;
4669         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4670         ndr->depth++;
4671         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4672         ndr->depth--;
4673         ndr_print_GUID(ndr, "source_dra", &r->source_dra);
4674         ndr_print_ptr(ndr, "source_dra_address", r->source_dra_address);
4675         ndr->depth++;
4676         if (r->source_dra_address) {
4677                 ndr_print_string(ndr, "source_dra_address", r->source_dra_address);
4678         }
4679         ndr->depth--;
4680         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4681         ndr_print_uint32(ndr, "replica_flags", r->replica_flags);
4682         ndr_print_uint32(ndr, "modify_fields", r->modify_fields);
4683         ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "options", r->options);
4684         ndr->depth--;
4685 }
4686
4687 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaModRequest *r)
4688 {
4689         if (ndr_flags & NDR_SCALARS) {
4690                 int level = ndr_push_get_switch_value(ndr, r);
4691                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4692                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4693                 switch (level) {
4694                         case 1: {
4695                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4696                         break; }
4697
4698                         default:
4699                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4700                 }
4701         }
4702         if (ndr_flags & NDR_BUFFERS) {
4703                 int level = ndr_push_get_switch_value(ndr, r);
4704                 switch (level) {
4705                         case 1:
4706                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4707                         break;
4708
4709                         default:
4710                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4711                 }
4712         }
4713         return NDR_ERR_SUCCESS;
4714 }
4715
4716 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaModRequest *r)
4717 {
4718         int level;
4719         int32_t _level;
4720         level = ndr_pull_get_switch_value(ndr, r);
4721         if (ndr_flags & NDR_SCALARS) {
4722                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4723                 if (_level != level) {
4724                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4725                 }
4726                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4727                 switch (level) {
4728                         case 1: {
4729                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4730                         break; }
4731
4732                         default:
4733                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4734                 }
4735         }
4736         if (ndr_flags & NDR_BUFFERS) {
4737                 switch (level) {
4738                         case 1:
4739                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4740                         break;
4741
4742                         default:
4743                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4744                 }
4745         }
4746         return NDR_ERR_SUCCESS;
4747 }
4748
4749 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaModRequest *r)
4750 {
4751         int level;
4752         level = ndr_print_get_switch_value(ndr, r);
4753         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaModRequest");
4754         switch (level) {
4755                 case 1:
4756                         ndr_print_drsuapi_DsReplicaModRequest1(ndr, "req1", &r->req1);
4757                 break;
4758
4759                 default:
4760                         ndr_print_bad_level(ndr, name, level);
4761         }
4762 }
4763
4764 static enum ndr_err_code ndr_push_drsuapi_DsMembershipType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsMembershipType r)
4765 {
4766         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
4767         return NDR_ERR_SUCCESS;
4768 }
4769
4770 static enum ndr_err_code ndr_pull_drsuapi_DsMembershipType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsMembershipType *r)
4771 {
4772         uint32_t v;
4773         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
4774         *r = v;
4775         return NDR_ERR_SUCCESS;
4776 }
4777
4778 _PUBLIC_ void ndr_print_drsuapi_DsMembershipType(struct ndr_print *ndr, const char *name, enum drsuapi_DsMembershipType r)
4779 {
4780         const char *val = NULL;
4781
4782         switch (r) {
4783                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS"; break;
4784                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS"; break;
4785                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS"; break;
4786                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2"; break;
4787                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS"; break;
4788                 case DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS"; break;
4789                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2"; break;
4790         }
4791         ndr_print_enum(ndr, name, "ENUM", val, r);
4792 }
4793
4794 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsCtr1 *r)
4795 {
4796         uint32_t cntr_info_array_1;
4797         uint32_t cntr_group_attrs_1;
4798         uint32_t cntr_sids_1;
4799         if (ndr_flags & NDR_SCALARS) {
4800                 NDR_CHECK(ndr_push_align(ndr, 5));
4801                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
4802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
4803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
4804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4805                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_attrs));
4806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
4807                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4808         }
4809         if (ndr_flags & NDR_BUFFERS) {
4810                 if (r->info_array) {
4811                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4812                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4813                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4814                         }
4815                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4816                                 if (r->info_array[cntr_info_array_1]) {
4817                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4818                                 }
4819                         }
4820                 }
4821                 if (r->group_attrs) {
4822                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4823                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4824                                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->group_attrs[cntr_group_attrs_1]));
4825                         }
4826                 }
4827                 if (r->sids) {
4828                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_sids));
4829                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4830                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_1]));
4831                         }
4832                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4833                                 if (r->sids[cntr_sids_1]) {
4834                                         NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4835                                 }
4836                         }
4837                 }
4838         }
4839         return NDR_ERR_SUCCESS;
4840 }
4841
4842 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsCtr1 *r)
4843 {
4844         uint32_t _ptr_info_array;
4845         uint32_t cntr_info_array_1;
4846         TALLOC_CTX *_mem_save_info_array_0;
4847         TALLOC_CTX *_mem_save_info_array_1;
4848         TALLOC_CTX *_mem_save_info_array_2;
4849         uint32_t _ptr_group_attrs;
4850         uint32_t cntr_group_attrs_1;
4851         TALLOC_CTX *_mem_save_group_attrs_0;
4852         TALLOC_CTX *_mem_save_group_attrs_1;
4853         uint32_t _ptr_sids;
4854         uint32_t cntr_sids_1;
4855         TALLOC_CTX *_mem_save_sids_0;
4856         TALLOC_CTX *_mem_save_sids_1;
4857         TALLOC_CTX *_mem_save_sids_2;
4858         if (ndr_flags & NDR_SCALARS) {
4859                 NDR_CHECK(ndr_pull_align(ndr, 5));
4860                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
4861                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_memberships));
4862                 if (r->num_memberships > 10000) {
4863                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4864                 }
4865                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
4866                 if (r->num_sids > 10000) {
4867                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4868                 }
4869                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4870                 if (_ptr_info_array) {
4871                         NDR_PULL_ALLOC(ndr, r->info_array);
4872                 } else {
4873                         r->info_array = NULL;
4874                 }
4875                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_attrs));
4876                 if (_ptr_group_attrs) {
4877                         NDR_PULL_ALLOC(ndr, r->group_attrs);
4878                 } else {
4879                         r->group_attrs = NULL;
4880                 }
4881                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4882                 if (_ptr_sids) {
4883                         NDR_PULL_ALLOC(ndr, r->sids);
4884                 } else {
4885                         r->sids = NULL;
4886                 }
4887                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4888         }
4889         if (ndr_flags & NDR_BUFFERS) {
4890                 if (r->info_array) {
4891                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4892                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4893                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4894                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
4895                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4896                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4897                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4898                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4899                                 if (_ptr_info_array) {
4900                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4901                                 } else {
4902                                         r->info_array[cntr_info_array_1] = NULL;
4903                                 }
4904                         }
4905                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4906                                 if (r->info_array[cntr_info_array_1]) {
4907                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4908                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4909                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4910                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
4911                                 }
4912                         }
4913                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
4914                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
4915                 }
4916                 if (r->group_attrs) {
4917                         _mem_save_group_attrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
4918                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4919                         NDR_CHECK(ndr_pull_array_size(ndr, &r->group_attrs));
4920                         NDR_PULL_ALLOC_N(ndr, r->group_attrs, ndr_get_array_size(ndr, &r->group_attrs));
4921                         _mem_save_group_attrs_1 = NDR_PULL_GET_MEM_CTX(ndr);
4922                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4923                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4924                                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->group_attrs[cntr_group_attrs_1]));
4925                         }
4926                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_1, 0);
4927                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_0, 0);
4928                 }
4929                 if (r->sids) {
4930                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4931                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4932                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4933                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4934                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4935                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4936                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4937                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4938                                 if (_ptr_sids) {
4939                                         NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_1]);
4940                                 } else {
4941                                         r->sids[cntr_sids_1] = NULL;
4942                                 }
4943                         }
4944                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4945                                 if (r->sids[cntr_sids_1]) {
4946                                         _mem_save_sids_2 = NDR_PULL_GET_MEM_CTX(ndr);
4947                                         NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_1], 0);
4948                                         NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4949                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_2, 0);
4950                                 }
4951                         }
4952                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
4953                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
4954                 }
4955                 if (r->info_array) {
4956                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->num_memberships));
4957                 }
4958                 if (r->group_attrs) {
4959                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->group_attrs, r->num_memberships));
4960                 }
4961                 if (r->sids) {
4962                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
4963                 }
4964         }
4965         return NDR_ERR_SUCCESS;
4966 }
4967
4968 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsCtr1 *r)
4969 {
4970         uint32_t cntr_info_array_1;
4971         uint32_t cntr_group_attrs_1;
4972         uint32_t cntr_sids_1;
4973         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsCtr1");
4974         ndr->depth++;
4975         ndr_print_NTSTATUS(ndr, "status", r->status);
4976         ndr_print_uint32(ndr, "num_memberships", r->num_memberships);
4977         ndr_print_uint32(ndr, "num_sids", r->num_sids);
4978         ndr_print_ptr(ndr, "info_array", r->info_array);
4979         ndr->depth++;
4980         if (r->info_array) {
4981                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->num_memberships);
4982                 ndr->depth++;
4983                 for (cntr_info_array_1=0;cntr_info_array_1<r->num_memberships;cntr_info_array_1++) {
4984                         char *idx_1=NULL;
4985                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
4986                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
4987                                 ndr->depth++;
4988                                 if (r->info_array[cntr_info_array_1]) {
4989                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
4990                                 }
4991                                 ndr->depth--;
4992                                 free(idx_1);
4993                         }
4994                 }
4995                 ndr->depth--;
4996         }
4997         ndr->depth--;
4998         ndr_print_ptr(ndr, "group_attrs", r->group_attrs);
4999         ndr->depth++;
5000         if (r->group_attrs) {
5001                 ndr->print(ndr, "%s: ARRAY(%d)", "group_attrs", (int)r->num_memberships);
5002                 ndr->depth++;
5003                 for (cntr_group_attrs_1=0;cntr_group_attrs_1<r->num_memberships;cntr_group_attrs_1++) {
5004                         char *idx_1=NULL;
5005                         if (asprintf(&idx_1, "[%d]", cntr_group_attrs_1) != -1) {
5006                                 ndr_print_samr_GroupAttrs(ndr, "group_attrs", r->group_attrs[cntr_group_attrs_1]);
5007                                 free(idx_1);
5008                         }
5009                 }
5010                 ndr->depth--;
5011         }
5012         ndr->depth--;
5013         ndr_print_ptr(ndr, "sids", r->sids);
5014         ndr->depth++;
5015         if (r->sids) {
5016                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
5017                 ndr->depth++;
5018                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
5019                         char *idx_1=NULL;
5020                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
5021                                 ndr_print_ptr(ndr, "sids", r->sids[cntr_sids_1]);
5022                                 ndr->depth++;
5023                                 if (r->sids[cntr_sids_1]) {
5024                                         ndr_print_dom_sid28(ndr, "sids", r->sids[cntr_sids_1]);
5025                                 }
5026                                 ndr->depth--;
5027                                 free(idx_1);
5028                         }
5029                 }
5030                 ndr->depth--;
5031         }
5032         ndr->depth--;
5033         ndr->depth--;
5034 }
5035
5036 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsCtr *r)
5037 {
5038         if (ndr_flags & NDR_SCALARS) {
5039                 int level = ndr_push_get_switch_value(ndr, r);
5040                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5041                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5042                 switch (level) {
5043                         case 1: {
5044                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
5045                         break; }
5046
5047                         default:
5048                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5049                 }
5050         }
5051         if (ndr_flags & NDR_BUFFERS) {
5052                 int level = ndr_push_get_switch_value(ndr, r);
5053                 switch (level) {
5054                         case 1:
5055                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
5056                         break;
5057
5058                         default:
5059                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5060                 }
5061         }
5062         return NDR_ERR_SUCCESS;
5063 }
5064
5065 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsCtr *r)
5066 {
5067         int level;
5068         int32_t _level;
5069         level = ndr_pull_get_switch_value(ndr, r);
5070         if (ndr_flags & NDR_SCALARS) {
5071                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5072                 if (_level != level) {
5073                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5074                 }
5075                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5076                 switch (level) {
5077                         case 1: {
5078                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
5079                         break; }
5080
5081                         default:
5082                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5083                 }
5084         }
5085         if (ndr_flags & NDR_BUFFERS) {
5086                 switch (level) {
5087                         case 1:
5088                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
5089                         break;
5090
5091                         default:
5092                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5093                 }
5094         }
5095         return NDR_ERR_SUCCESS;
5096 }
5097
5098 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsCtr *r)
5099 {
5100         int level;
5101         level = ndr_print_get_switch_value(ndr, r);
5102         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsCtr");
5103         switch (level) {
5104                 case 1:
5105                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
5106                 break;
5107
5108                 default:
5109                         ndr_print_bad_level(ndr, name, level);
5110         }
5111 }
5112
5113 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsRequest1 *r)
5114 {
5115         uint32_t cntr_info_array_1;
5116         if (ndr_flags & NDR_SCALARS) {
5117                 NDR_CHECK(ndr_push_align(ndr, 5));
5118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
5120                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
5121                 NDR_CHECK(ndr_push_drsuapi_DsMembershipType(ndr, NDR_SCALARS, r->type));
5122                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
5123                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5124         }
5125         if (ndr_flags & NDR_BUFFERS) {
5126                 if (r->info_array) {
5127                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5128                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5129                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
5130                         }
5131                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5132                                 if (r->info_array[cntr_info_array_1]) {
5133                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5134                                 }
5135                         }
5136                 }
5137                 if (r->domain) {
5138                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5139                 }
5140         }
5141         return NDR_ERR_SUCCESS;
5142 }
5143
5144 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsRequest1 *r)
5145 {
5146         uint32_t _ptr_info_array;
5147         uint32_t cntr_info_array_1;
5148         TALLOC_CTX *_mem_save_info_array_0;
5149         TALLOC_CTX *_mem_save_info_array_1;
5150         TALLOC_CTX *_mem_save_info_array_2;
5151         uint32_t _ptr_domain;
5152         TALLOC_CTX *_mem_save_domain_0;
5153         if (ndr_flags & NDR_SCALARS) {
5154                 NDR_CHECK(ndr_pull_align(ndr, 5));
5155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5156                 if (r->count < 1 || r->count > 10000) {
5157                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5158                 }
5159                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5160                 if (_ptr_info_array) {
5161                         NDR_PULL_ALLOC(ndr, r->info_array);
5162                 } else {
5163                         r->info_array = NULL;
5164                 }
5165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
5166                 NDR_CHECK(ndr_pull_drsuapi_DsMembershipType(ndr, NDR_SCALARS, &r->type));
5167                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
5168                 if (_ptr_domain) {
5169                         NDR_PULL_ALLOC(ndr, r->domain);
5170                 } else {
5171                         r->domain = NULL;
5172                 }
5173                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5174         }
5175         if (ndr_flags & NDR_BUFFERS) {
5176                 if (r->info_array) {
5177                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5178                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5179                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
5180                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
5181                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5182                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5183                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5184                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5185                                 if (_ptr_info_array) {
5186                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
5187                                 } else {
5188                                         r->info_array[cntr_info_array_1] = NULL;
5189                                 }
5190                         }
5191                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5192                                 if (r->info_array[cntr_info_array_1]) {
5193                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
5194                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
5195                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5196                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
5197                                 }
5198                         }
5199                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
5200                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
5201                 }
5202                 if (r->domain) {
5203                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
5204                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
5205                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5206                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
5207                 }
5208                 if (r->info_array) {
5209                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->count));
5210                 }
5211         }
5212         return NDR_ERR_SUCCESS;
5213 }
5214
5215 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsRequest1 *r)
5216 {
5217         uint32_t cntr_info_array_1;
5218         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsRequest1");
5219         ndr->depth++;
5220         ndr_print_uint32(ndr, "count", r->count);
5221         ndr_print_ptr(ndr, "info_array", r->info_array);
5222         ndr->depth++;
5223         if (r->info_array) {
5224                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->count);
5225                 ndr->depth++;
5226                 for (cntr_info_array_1=0;cntr_info_array_1<r->count;cntr_info_array_1++) {
5227                         char *idx_1=NULL;
5228                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
5229                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
5230                                 ndr->depth++;
5231                                 if (r->info_array[cntr_info_array_1]) {
5232                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
5233                                 }
5234                                 ndr->depth--;
5235                                 free(idx_1);
5236                         }
5237                 }
5238                 ndr->depth--;
5239         }
5240         ndr->depth--;
5241         ndr_print_uint32(ndr, "flags", r->flags);
5242         ndr_print_drsuapi_DsMembershipType(ndr, "type", r->type);
5243         ndr_print_ptr(ndr, "domain", r->domain);
5244         ndr->depth++;
5245         if (r->domain) {
5246                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "domain", r->domain);
5247         }
5248         ndr->depth--;
5249         ndr->depth--;
5250 }
5251
5252 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsRequest *r)
5253 {
5254         if (ndr_flags & NDR_SCALARS) {
5255                 int level = ndr_push_get_switch_value(ndr, r);
5256                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5257                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5258                 switch (level) {
5259                         case 1: {
5260                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5261                         break; }
5262
5263                         default:
5264                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5265                 }
5266         }
5267         if (ndr_flags & NDR_BUFFERS) {
5268                 int level = ndr_push_get_switch_value(ndr, r);
5269                 switch (level) {
5270                         case 1:
5271                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5272                         break;
5273
5274                         default:
5275                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5276                 }
5277         }
5278         return NDR_ERR_SUCCESS;
5279 }
5280
5281 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsRequest *r)
5282 {
5283         int level;
5284         int32_t _level;
5285         level = ndr_pull_get_switch_value(ndr, r);
5286         if (ndr_flags & NDR_SCALARS) {
5287                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5288                 if (_level != level) {
5289                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5290                 }
5291                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5292                 switch (level) {
5293                         case 1: {
5294                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5295                         break; }
5296
5297                         default:
5298                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5299                 }
5300         }
5301         if (ndr_flags & NDR_BUFFERS) {
5302                 switch (level) {
5303                         case 1:
5304                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5305                         break;
5306
5307                         default:
5308                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5309                 }
5310         }
5311         return NDR_ERR_SUCCESS;
5312 }
5313
5314 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsRequest *r)
5315 {
5316         int level;
5317         level = ndr_print_get_switch_value(ndr, r);
5318         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsRequest");
5319         switch (level) {
5320                 case 1:
5321                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req1", &r->req1);
5322                 break;
5323
5324                 default:
5325                         ndr_print_bad_level(ndr, name, level);
5326         }
5327 }
5328
5329 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5330 {
5331         if (ndr_flags & NDR_SCALARS) {
5332                 NDR_CHECK(ndr_push_align(ndr, 5));
5333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
5334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
5335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
5336                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
5337                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5338         }
5339         if (ndr_flags & NDR_BUFFERS) {
5340                 if (r->data) {
5341                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
5342                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
5343                 }
5344         }
5345         return NDR_ERR_SUCCESS;
5346 }
5347
5348 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5349 {
5350         uint32_t _ptr_data;
5351         TALLOC_CTX *_mem_save_data_0;
5352         if (ndr_flags & NDR_SCALARS) {
5353                 NDR_CHECK(ndr_pull_align(ndr, 5));
5354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
5355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
5356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
5357                 if (r->length > 0x00A00000) {
5358                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5359                 }
5360                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
5361                 if (_ptr_data) {
5362                         NDR_PULL_ALLOC(ndr, r->data);
5363                 } else {
5364                         r->data = NULL;
5365                 }
5366                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5367         }
5368         if (ndr_flags & NDR_BUFFERS) {
5369                 if (r->data) {
5370                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5371                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
5372                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
5373                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
5374                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
5375                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
5376                 }
5377                 if (r->data) {
5378                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
5379                 }
5380         }
5381         return NDR_ERR_SUCCESS;
5382 }
5383
5384 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5385 {
5386         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogRequest1");
5387         ndr->depth++;
5388         ndr_print_uint32(ndr, "unknown1", r->unknown1);
5389         ndr_print_uint32(ndr, "unknown2", r->unknown2);
5390         ndr_print_uint32(ndr, "length", r->length);
5391         ndr_print_ptr(ndr, "data", r->data);
5392         ndr->depth++;
5393         if (r->data) {
5394                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
5395         }
5396         ndr->depth--;
5397         ndr->depth--;
5398 }
5399
5400 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5401 {
5402         if (ndr_flags & NDR_SCALARS) {
5403                 int level = ndr_push_get_switch_value(ndr, r);
5404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5405                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5406                 switch (level) {
5407                         case 1: {
5408                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5409                         break; }
5410
5411                         default:
5412                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5413                 }
5414         }
5415         if (ndr_flags & NDR_BUFFERS) {
5416                 int level = ndr_push_get_switch_value(ndr, r);
5417                 switch (level) {
5418                         case 1:
5419                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5420                         break;
5421
5422                         default:
5423                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5424                 }
5425         }
5426         return NDR_ERR_SUCCESS;
5427 }
5428
5429 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogRequest *r)
5430 {
5431         int level;
5432         uint32_t _level;
5433         level = ndr_pull_get_switch_value(ndr, r);
5434         if (ndr_flags & NDR_SCALARS) {
5435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5436                 if (_level != level) {
5437                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5438                 }
5439                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5440                 switch (level) {
5441                         case 1: {
5442                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5443                         break; }
5444
5445                         default:
5446                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5447                 }
5448         }
5449         if (ndr_flags & NDR_BUFFERS) {
5450                 switch (level) {
5451                         case 1:
5452                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5453                         break;
5454
5455                         default:
5456                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5457                 }
5458         }
5459         return NDR_ERR_SUCCESS;
5460 }
5461
5462 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5463 {
5464         int level;
5465         level = ndr_print_get_switch_value(ndr, r);
5466         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogRequest");
5467         switch (level) {
5468                 case 1:
5469                         ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(ndr, "req1", &r->req1);
5470                 break;
5471
5472                 default:
5473                         ndr_print_bad_level(ndr, name, level);
5474         }
5475 }
5476
5477 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5478 {
5479         if (ndr_flags & NDR_SCALARS) {
5480                 NDR_CHECK(ndr_push_align(ndr, 8));
5481                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
5482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
5483                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5484                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time2));
5485                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5486                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time4));
5487                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5488                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time6));
5489                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
5490                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data1));
5491                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data2));
5492                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5493         }
5494         if (ndr_flags & NDR_BUFFERS) {
5495                 if (r->data1) {
5496                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length1));
5497                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data1, r->length1));
5498                 }
5499                 if (r->data2) {
5500                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length2));
5501                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data2, r->length2));
5502                 }
5503         }
5504         return NDR_ERR_SUCCESS;
5505 }
5506
5507 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5508 {
5509         uint32_t _ptr_data1;
5510         TALLOC_CTX *_mem_save_data1_0;
5511         uint32_t _ptr_data2;
5512         TALLOC_CTX *_mem_save_data2_0;
5513         if (ndr_flags & NDR_SCALARS) {
5514                 NDR_CHECK(ndr_pull_align(ndr, 8));
5515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length1));
5516                 if (r->length1 > 0x00A00000) {
5517                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5518                 }
5519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length2));
5520                 if (r->length2 > 0x00A00000) {
5521                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5522                 }
5523                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5524                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time2));
5525                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5526                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time4));
5527                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5528                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time6));
5529                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
5530                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data1));
5531                 if (_ptr_data1) {
5532                         NDR_PULL_ALLOC(ndr, r->data1);
5533                 } else {
5534                         r->data1 = NULL;
5535                 }
5536                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data2));
5537                 if (_ptr_data2) {
5538                         NDR_PULL_ALLOC(ndr, r->data2);
5539                 } else {
5540                         r->data2 = NULL;
5541                 }
5542                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5543         }
5544         if (ndr_flags & NDR_BUFFERS) {
5545                 if (r->data1) {
5546                         _mem_save_data1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5547                         NDR_PULL_SET_MEM_CTX(ndr, r->data1, 0);
5548                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data1));
5549                         NDR_PULL_ALLOC_N(ndr, r->data1, ndr_get_array_size(ndr, &r->data1));
5550                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data1, ndr_get_array_size(ndr, &r->data1)));
5551                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data1_0, 0);
5552                 }
5553                 if (r->data2) {
5554                         _mem_save_data2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5555                         NDR_PULL_SET_MEM_CTX(ndr, r->data2, 0);
5556                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data2));
5557                         NDR_PULL_ALLOC_N(ndr, r->data2, ndr_get_array_size(ndr, &r->data2));
5558                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data2, ndr_get_array_size(ndr, &r->data2)));
5559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data2_0, 0);
5560                 }
5561                 if (r->data1) {
5562                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data1, r->length1));
5563                 }
5564                 if (r->data2) {
5565                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data2, r->length2));
5566                 }
5567         }
5568         return NDR_ERR_SUCCESS;
5569 }
5570
5571 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5572 {
5573         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogInfo1");
5574         ndr->depth++;
5575         ndr_print_uint32(ndr, "length1", r->length1);
5576         ndr_print_uint32(ndr, "length2", r->length2);
5577         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5578         ndr_print_NTTIME(ndr, "time2", r->time2);
5579         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5580         ndr_print_NTTIME(ndr, "time4", r->time4);
5581         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5582         ndr_print_NTTIME(ndr, "time6", r->time6);
5583         ndr_print_NTSTATUS(ndr, "status", r->status);
5584         ndr_print_ptr(ndr, "data1", r->data1);
5585         ndr->depth++;
5586         if (r->data1) {
5587                 ndr_print_array_uint8(ndr, "data1", r->data1, r->length1);
5588         }
5589         ndr->depth--;
5590         ndr_print_ptr(ndr, "data2", r->data2);
5591         ndr->depth++;
5592         if (r->data2) {
5593                 ndr_print_array_uint8(ndr, "data2", r->data2, r->length2);
5594         }
5595         ndr->depth--;
5596         ndr->depth--;
5597 }
5598
5599 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5600 {
5601         if (ndr_flags & NDR_SCALARS) {
5602                 int level = ndr_push_get_switch_value(ndr, r);
5603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5604                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5605                 switch (level) {
5606                         case 1: {
5607                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5608                         break; }
5609
5610                         default:
5611                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5612                 }
5613         }
5614         if (ndr_flags & NDR_BUFFERS) {
5615                 int level = ndr_push_get_switch_value(ndr, r);
5616                 switch (level) {
5617                         case 1:
5618                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5619                         break;
5620
5621                         default:
5622                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5623                 }
5624         }
5625         return NDR_ERR_SUCCESS;
5626 }
5627
5628 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogInfo *r)
5629 {
5630         int level;
5631         uint32_t _level;
5632         level = ndr_pull_get_switch_value(ndr, r);
5633         if (ndr_flags & NDR_SCALARS) {
5634                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5635                 if (_level != level) {
5636                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5637                 }
5638                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5639                 switch (level) {
5640                         case 1: {
5641                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5642                         break; }
5643
5644                         default:
5645                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5646                 }
5647         }
5648         if (ndr_flags & NDR_BUFFERS) {
5649                 switch (level) {
5650                         case 1:
5651                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5652                         break;
5653
5654                         default:
5655                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5656                 }
5657         }
5658         return NDR_ERR_SUCCESS;
5659 }
5660
5661 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5662 {
5663         int level;
5664         level = ndr_print_get_switch_value(ndr, r);
5665         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogInfo");
5666         switch (level) {
5667                 case 1:
5668                         ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(ndr, "info1", &r->info1);
5669                 break;
5670
5671                 default:
5672                         ndr_print_bad_level(ndr, name, level);
5673         }
5674 }
5675
5676 static enum ndr_err_code ndr_push_drsuapi_DsNameStatus(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameStatus r)
5677 {
5678         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5679         return NDR_ERR_SUCCESS;
5680 }
5681
5682 static enum ndr_err_code ndr_pull_drsuapi_DsNameStatus(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameStatus *r)
5683 {
5684         uint32_t v;
5685         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5686         *r = v;
5687         return NDR_ERR_SUCCESS;
5688 }
5689
5690 _PUBLIC_ void ndr_print_drsuapi_DsNameStatus(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameStatus r)
5691 {
5692         const char *val = NULL;
5693
5694         switch (r) {
5695                 case DRSUAPI_DS_NAME_STATUS_OK: val = "DRSUAPI_DS_NAME_STATUS_OK"; break;
5696                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR: val = "DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR"; break;
5697                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND: val = "DRSUAPI_DS_NAME_STATUS_NOT_FOUND"; break;
5698                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE: val = "DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE"; break;
5699                 case DRSUAPI_DS_NAME_STATUS_NO_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_MAPPING"; break;
5700                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY: val = "DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY"; break;
5701                 case DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING"; break;
5702                 case DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL"; break;
5703         }
5704         ndr_print_enum(ndr, name, "ENUM", val, r);
5705 }
5706
5707 static enum ndr_err_code ndr_push_drsuapi_DsNameFlags(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFlags r)
5708 {
5709         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5710         return NDR_ERR_SUCCESS;
5711 }
5712
5713 static enum ndr_err_code ndr_pull_drsuapi_DsNameFlags(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFlags *r)
5714 {
5715         uint32_t v;
5716         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5717         *r = v;
5718         return NDR_ERR_SUCCESS;
5719 }
5720
5721 _PUBLIC_ void ndr_print_drsuapi_DsNameFlags(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFlags r)
5722 {
5723         const char *val = NULL;
5724
5725         switch (r) {
5726                 case DRSUAPI_DS_NAME_FLAG_NO_FLAGS: val = "DRSUAPI_DS_NAME_FLAG_NO_FLAGS"; break;
5727                 case DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY: val = "DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY"; break;
5728                 case DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC: val = "DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC"; break;
5729                 case DRSUAPI_DS_NAME_FLAG_GCVERIFY: val = "DRSUAPI_DS_NAME_FLAG_GCVERIFY"; break;
5730                 case DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL"; break;
5731         }
5732         ndr_print_enum(ndr, name, "ENUM", val, r);
5733 }
5734
5735 static enum ndr_err_code ndr_push_drsuapi_DsNameFormat(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFormat r)
5736 {
5737         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5738         return NDR_ERR_SUCCESS;
5739 }
5740
5741 static enum ndr_err_code ndr_pull_drsuapi_DsNameFormat(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFormat *r)
5742 {
5743         uint32_t v;
5744         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5745         *r = v;
5746         return NDR_ERR_SUCCESS;
5747 }
5748
5749 _PUBLIC_ void ndr_print_drsuapi_DsNameFormat(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFormat r)
5750 {
5751         const char *val = NULL;
5752
5753         switch (r) {
5754                 case DRSUAPI_DS_NAME_FORMAT_UNKNOWN: val = "DRSUAPI_DS_NAME_FORMAT_UNKNOWN"; break;
5755                 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: val = "DRSUAPI_DS_NAME_FORMAT_FQDN_1779"; break;
5756                 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: val = "DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT"; break;
5757                 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: val = "DRSUAPI_DS_NAME_FORMAT_DISPLAY"; break;
5758                 case DRSUAPI_DS_NAME_FORMAT_GUID: val = "DRSUAPI_DS_NAME_FORMAT_GUID"; break;
5759                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL"; break;
5760                 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL"; break;
5761                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX"; break;
5762                 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL"; break;
5763                 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: val = "DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY"; break;
5764                 case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: val = "DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN"; break;
5765         }
5766         ndr_print_enum(ndr, name, "ENUM", val, r);
5767 }
5768
5769 static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameString *r)
5770 {
5771         if (ndr_flags & NDR_SCALARS) {
5772                 NDR_CHECK(ndr_push_align(ndr, 5));
5773                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
5774                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5775         }
5776         if (ndr_flags & NDR_BUFFERS) {
5777                 if (r->str) {
5778                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5779                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5780                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5781                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str, ndr_charset_length(r->str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5782                 }
5783         }
5784         return NDR_ERR_SUCCESS;
5785 }
5786
5787 static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameString *r)
5788 {
5789         uint32_t _ptr_str;
5790         TALLOC_CTX *_mem_save_str_0;
5791         if (ndr_flags & NDR_SCALARS) {
5792                 NDR_CHECK(ndr_pull_align(ndr, 5));
5793                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
5794                 if (_ptr_str) {
5795                         NDR_PULL_ALLOC(ndr, r->str);
5796                 } else {
5797                         r->str = NULL;
5798                 }
5799                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5800         }
5801         if (ndr_flags & NDR_BUFFERS) {
5802                 if (r->str) {
5803                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
5804                         NDR_PULL_SET_MEM_CTX(ndr, r->str, 0);
5805                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str));
5806                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str));
5807                         if (ndr_get_array_length(ndr, &r->str) > ndr_get_array_size(ndr, &r->str)) {
5808                                 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));
5809                         }
5810                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t)));
5811                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t), CH_UTF16));
5812                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
5813                 }
5814         }
5815         return NDR_ERR_SUCCESS;
5816 }
5817
5818 _PUBLIC_ void ndr_print_drsuapi_DsNameString(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameString *r)
5819 {
5820         ndr_print_struct(ndr, name, "drsuapi_DsNameString");
5821         ndr->depth++;
5822         ndr_print_ptr(ndr, "str", r->str);
5823         ndr->depth++;
5824         if (r->str) {
5825                 ndr_print_string(ndr, "str", r->str);
5826         }
5827         ndr->depth--;
5828         ndr->depth--;
5829 }
5830
5831 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameRequest1 *r)
5832 {
5833         uint32_t cntr_names_1;
5834         if (ndr_flags & NDR_SCALARS) {
5835                 NDR_CHECK(ndr_push_align(ndr, 5));
5836                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->codepage));
5837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->language));
5838                 NDR_CHECK(ndr_push_drsuapi_DsNameFlags(ndr, NDR_SCALARS, r->format_flags));
5839                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_offered));
5840                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
5841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5842                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
5843                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5844         }
5845         if (ndr_flags & NDR_BUFFERS) {
5846                 if (r->names) {
5847                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5848                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5849                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5850                         }
5851                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5852                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5853                         }
5854                 }
5855         }
5856         return NDR_ERR_SUCCESS;
5857 }
5858
5859 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameRequest1 *r)
5860 {
5861         uint32_t _ptr_names;
5862         uint32_t cntr_names_1;
5863         TALLOC_CTX *_mem_save_names_0;
5864         TALLOC_CTX *_mem_save_names_1;
5865         if (ndr_flags & NDR_SCALARS) {
5866                 NDR_CHECK(ndr_pull_align(ndr, 5));
5867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->codepage));
5868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->language));
5869                 NDR_CHECK(ndr_pull_drsuapi_DsNameFlags(ndr, NDR_SCALARS, &r->format_flags));
5870                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_offered));
5871                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_desired));
5872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5873                 if (r->count < 1 || r->count > 10000) {
5874                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5875                 }
5876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
5877                 if (_ptr_names) {
5878                         NDR_PULL_ALLOC(ndr, r->names);
5879                 } else {
5880                         r->names = NULL;
5881                 }
5882                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5883         }
5884         if (ndr_flags & NDR_BUFFERS) {
5885                 if (r->names) {
5886                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5887                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5888                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
5889                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
5890                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
5891                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5892                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5893                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5894                         }
5895                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5896                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5897                         }
5898                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
5899                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
5900                 }
5901                 if (r->names) {
5902                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
5903                 }
5904         }
5905         return NDR_ERR_SUCCESS;
5906 }
5907
5908 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameRequest1 *r)
5909 {
5910         uint32_t cntr_names_1;
5911         ndr_print_struct(ndr, name, "drsuapi_DsNameRequest1");
5912         ndr->depth++;
5913         ndr_print_uint32(ndr, "codepage", r->codepage);
5914         ndr_print_uint32(ndr, "language", r->language);
5915         ndr_print_drsuapi_DsNameFlags(ndr, "format_flags", r->format_flags);
5916         ndr_print_drsuapi_DsNameFormat(ndr, "format_offered", r->format_offered);
5917         ndr_print_drsuapi_DsNameFormat(ndr, "format_desired", r->format_desired);
5918         ndr_print_uint32(ndr, "count", r->count);
5919         ndr_print_ptr(ndr, "names", r->names);
5920         ndr->depth++;
5921         if (r->names) {
5922                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
5923                 ndr->depth++;
5924                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
5925                         char *idx_1=NULL;
5926                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
5927                                 ndr_print_drsuapi_DsNameString(ndr, "names", &r->names[cntr_names_1]);
5928                                 free(idx_1);
5929                         }
5930                 }
5931                 ndr->depth--;
5932         }
5933         ndr->depth--;
5934         ndr->depth--;
5935 }
5936
5937 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameRequest *r)
5938 {
5939         if (ndr_flags & NDR_SCALARS) {
5940                 int level = ndr_push_get_switch_value(ndr, r);
5941                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5942                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5943                 switch (level) {
5944                         case 1: {
5945                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5946                         break; }
5947
5948                         default:
5949                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5950                 }
5951         }
5952         if (ndr_flags & NDR_BUFFERS) {
5953                 int level = ndr_push_get_switch_value(ndr, r);
5954                 switch (level) {
5955                         case 1:
5956                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5957                         break;
5958
5959                         default:
5960                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5961                 }
5962         }
5963         return NDR_ERR_SUCCESS;
5964 }
5965
5966 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameRequest *r)
5967 {
5968         int level;
5969         int32_t _level;
5970         level = ndr_pull_get_switch_value(ndr, r);
5971         if (ndr_flags & NDR_SCALARS) {
5972                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5973                 if (_level != level) {
5974                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5975                 }
5976                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5977                 switch (level) {
5978                         case 1: {
5979                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5980                         break; }
5981
5982                         default:
5983                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5984                 }
5985         }
5986         if (ndr_flags & NDR_BUFFERS) {
5987                 switch (level) {
5988                         case 1:
5989                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5990                         break;
5991
5992                         default:
5993                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5994                 }
5995         }
5996         return NDR_ERR_SUCCESS;
5997 }
5998
5999 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameRequest *r)
6000 {
6001         int level;
6002         level = ndr_print_get_switch_value(ndr, r);
6003         ndr_print_union(ndr, name, level, "drsuapi_DsNameRequest");
6004         switch (level) {
6005                 case 1:
6006                         ndr_print_drsuapi_DsNameRequest1(ndr, "req1", &r->req1);
6007                 break;
6008
6009                 default:
6010                         ndr_print_bad_level(ndr, name, level);
6011         }
6012 }
6013
6014 static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameInfo1 *r)
6015 {
6016         if (ndr_flags & NDR_SCALARS) {
6017                 NDR_CHECK(ndr_push_align(ndr, 5));
6018                 NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
6019                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
6020                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
6021                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6022         }
6023         if (ndr_flags & NDR_BUFFERS) {
6024                 if (r->dns_domain_name) {
6025                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
6026                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6027                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
6028                         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));
6029                 }
6030                 if (r->result_name) {
6031                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
6032                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6033                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
6034                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->result_name, ndr_charset_length(r->result_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6035                 }
6036         }
6037         return NDR_ERR_SUCCESS;
6038 }
6039
6040 static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameInfo1 *r)
6041 {
6042         uint32_t _ptr_dns_domain_name;
6043         TALLOC_CTX *_mem_save_dns_domain_name_0;
6044         uint32_t _ptr_result_name;
6045         TALLOC_CTX *_mem_save_result_name_0;
6046         if (ndr_flags & NDR_SCALARS) {
6047                 NDR_CHECK(ndr_pull_align(ndr, 5));
6048                 NDR_CHECK(ndr_pull_drsuapi_DsNameStatus(ndr, NDR_SCALARS, &r->status));
6049                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain_name));
6050                 if (_ptr_dns_domain_name) {
6051                         NDR_PULL_ALLOC(ndr, r->dns_domain_name);
6052                 } else {
6053                         r->dns_domain_name = NULL;
6054                 }
6055                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_result_name));
6056                 if (_ptr_result_name) {
6057                         NDR_PULL_ALLOC(ndr, r->result_name);
6058                 } else {
6059                         r->result_name = NULL;
6060                 }
6061                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6062         }
6063         if (ndr_flags & NDR_BUFFERS) {
6064                 if (r->dns_domain_name) {
6065                         _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6066                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
6067                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain_name));
6068                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain_name));
6069                         if (ndr_get_array_length(ndr, &r->dns_domain_name) > ndr_get_array_size(ndr, &r->dns_domain_name)) {
6070                                 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));
6071                         }
6072                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t)));
6073                         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));
6074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
6075                 }
6076                 if (r->result_name) {
6077                         _mem_save_result_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6078                         NDR_PULL_SET_MEM_CTX(ndr, r->result_name, 0);
6079                         NDR_CHECK(ndr_pull_array_size(ndr, &r->result_name));
6080                         NDR_CHECK(ndr_pull_array_length(ndr, &r->result_name));
6081                         if (ndr_get_array_length(ndr, &r->result_name) > ndr_get_array_size(ndr, &r->result_name)) {
6082                                 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));
6083                         }
6084                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t)));
6085                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t), CH_UTF16));
6086                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_result_name_0, 0);
6087                 }
6088         }
6089         return NDR_ERR_SUCCESS;
6090 }
6091
6092 _PUBLIC_ void ndr_print_drsuapi_DsNameInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameInfo1 *r)
6093 {
6094         ndr_print_struct(ndr, name, "drsuapi_DsNameInfo1");
6095         ndr->depth++;
6096         ndr_print_drsuapi_DsNameStatus(ndr, "status", r->status);
6097         ndr_print_ptr(ndr, "dns_domain_name", r->dns_domain_name);
6098         ndr->depth++;
6099         if (r->dns_domain_name) {
6100                 ndr_print_string(ndr, "dns_domain_name", r->dns_domain_name);
6101         }
6102         ndr->depth--;
6103         ndr_print_ptr(ndr, "result_name", r->result_name);
6104         ndr->depth++;
6105         if (r->result_name) {
6106                 ndr_print_string(ndr, "result_name", r->result_name);
6107         }
6108         ndr->depth--;
6109         ndr->depth--;
6110 }
6111
6112 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameCtr1 *r)
6113 {
6114         uint32_t cntr_array_1;
6115         if (ndr_flags & NDR_SCALARS) {
6116                 NDR_CHECK(ndr_push_align(ndr, 5));
6117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6118                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
6119                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6120         }
6121         if (ndr_flags & NDR_BUFFERS) {
6122                 if (r->array) {
6123                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6124                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6125                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6126                         }
6127                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6128                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6129                         }
6130                 }
6131         }
6132         return NDR_ERR_SUCCESS;
6133 }
6134
6135 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameCtr1 *r)
6136 {
6137         uint32_t _ptr_array;
6138         uint32_t cntr_array_1;
6139         TALLOC_CTX *_mem_save_array_0;
6140         TALLOC_CTX *_mem_save_array_1;
6141         if (ndr_flags & NDR_SCALARS) {
6142                 NDR_CHECK(ndr_pull_align(ndr, 5));
6143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6144                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
6145                 if (_ptr_array) {
6146                         NDR_PULL_ALLOC(ndr, r->array);
6147                 } else {
6148                         r->array = NULL;
6149                 }
6150                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6151         }
6152         if (ndr_flags & NDR_BUFFERS) {
6153                 if (r->array) {
6154                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6155                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6156                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
6157                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
6158                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
6159                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6160                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6161                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6162                         }
6163                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6164                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6165                         }
6166                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
6167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
6168                 }
6169                 if (r->array) {
6170                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
6171                 }
6172         }
6173         return NDR_ERR_SUCCESS;
6174 }
6175
6176 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameCtr1 *r)
6177 {
6178         uint32_t cntr_array_1;
6179         ndr_print_struct(ndr, name, "drsuapi_DsNameCtr1");
6180         ndr->depth++;
6181         ndr_print_uint32(ndr, "count", r->count);
6182         ndr_print_ptr(ndr, "array", r->array);
6183         ndr->depth++;
6184         if (r->array) {
6185                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
6186                 ndr->depth++;
6187                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
6188                         char *idx_1=NULL;
6189                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
6190                                 ndr_print_drsuapi_DsNameInfo1(ndr, "array", &r->array[cntr_array_1]);
6191                                 free(idx_1);
6192                         }
6193                 }
6194                 ndr->depth--;
6195         }
6196         ndr->depth--;
6197         ndr->depth--;
6198 }
6199
6200 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameCtr *r)
6201 {
6202         if (ndr_flags & NDR_SCALARS) {
6203                 int level = ndr_push_get_switch_value(ndr, r);
6204                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6205                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6206                 switch (level) {
6207                         case 1: {
6208                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
6209                         break; }
6210
6211                         default:
6212                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6213                 }
6214         }
6215         if (ndr_flags & NDR_BUFFERS) {
6216                 int level = ndr_push_get_switch_value(ndr, r);
6217                 switch (level) {
6218                         case 1:
6219                                 if (r->ctr1) {
6220                                         NDR_CHECK(ndr_push_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6221                                 }
6222                         break;
6223
6224                         default:
6225                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6226                 }
6227         }
6228         return NDR_ERR_SUCCESS;
6229 }
6230
6231 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameCtr *r)
6232 {
6233         int level;
6234         int32_t _level;
6235         TALLOC_CTX *_mem_save_ctr1_0;
6236         level = ndr_pull_get_switch_value(ndr, r);
6237         if (ndr_flags & NDR_SCALARS) {
6238                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6239                 if (_level != level) {
6240                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6241                 }
6242                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6243                 switch (level) {
6244                         case 1: {
6245                                 uint32_t _ptr_ctr1;
6246                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
6247                                 if (_ptr_ctr1) {
6248                                         NDR_PULL_ALLOC(ndr, r->ctr1);
6249                                 } else {
6250                                         r->ctr1 = NULL;
6251                                 }
6252                         break; }
6253
6254                         default:
6255                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6256                 }
6257         }
6258         if (ndr_flags & NDR_BUFFERS) {
6259                 switch (level) {
6260                         case 1:
6261                                 if (r->ctr1) {
6262                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6263                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
6264                                         NDR_CHECK(ndr_pull_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6265                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
6266                                 }
6267                         break;
6268
6269                         default:
6270                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6271                 }
6272         }
6273         return NDR_ERR_SUCCESS;
6274 }
6275
6276 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameCtr *r)
6277 {
6278         int level;
6279         level = ndr_print_get_switch_value(ndr, r);
6280         ndr_print_union(ndr, name, level, "drsuapi_DsNameCtr");
6281         switch (level) {
6282                 case 1:
6283                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
6284                         ndr->depth++;
6285                         if (r->ctr1) {
6286                                 ndr_print_drsuapi_DsNameCtr1(ndr, "ctr1", r->ctr1);
6287                         }
6288                         ndr->depth--;
6289                 break;
6290
6291                 default:
6292                         ndr_print_bad_level(ndr, name, level);
6293         }
6294 }
6295
6296 static enum ndr_err_code ndr_push_drsuapi_DsSpnOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsSpnOperation r)
6297 {
6298         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6299         return NDR_ERR_SUCCESS;
6300 }
6301
6302 static enum ndr_err_code ndr_pull_drsuapi_DsSpnOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsSpnOperation *r)
6303 {
6304         uint32_t v;
6305         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6306         *r = v;
6307         return NDR_ERR_SUCCESS;
6308 }
6309
6310 _PUBLIC_ void ndr_print_drsuapi_DsSpnOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsSpnOperation r)
6311 {
6312         const char *val = NULL;
6313
6314         switch (r) {
6315                 case DRSUAPI_DS_SPN_OPERATION_ADD: val = "DRSUAPI_DS_SPN_OPERATION_ADD"; break;
6316                 case DRSUAPI_DS_SPN_OPERATION_REPLACE: val = "DRSUAPI_DS_SPN_OPERATION_REPLACE"; break;
6317                 case DRSUAPI_DS_SPN_OPERATION_DELETE: val = "DRSUAPI_DS_SPN_OPERATION_DELETE"; break;
6318         }
6319         ndr_print_enum(ndr, name, "ENUM", val, r);
6320 }
6321
6322 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6323 {
6324         uint32_t cntr_spn_names_1;
6325         if (ndr_flags & NDR_SCALARS) {
6326                 NDR_CHECK(ndr_push_align(ndr, 5));
6327                 NDR_CHECK(ndr_push_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, r->operation));
6328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
6329                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
6330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6331                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
6332                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6333         }
6334         if (ndr_flags & NDR_BUFFERS) {
6335                 if (r->object_dn) {
6336                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6337                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6338                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6339                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6340                 }
6341                 if (r->spn_names) {
6342                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6343                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6344                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6345                         }
6346                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6347                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6348                         }
6349                 }
6350         }
6351         return NDR_ERR_SUCCESS;
6352 }
6353
6354 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnRequest1 *r)
6355 {
6356         uint32_t _ptr_object_dn;
6357         TALLOC_CTX *_mem_save_object_dn_0;
6358         uint32_t _ptr_spn_names;
6359         uint32_t cntr_spn_names_1;
6360         TALLOC_CTX *_mem_save_spn_names_0;
6361         TALLOC_CTX *_mem_save_spn_names_1;
6362         if (ndr_flags & NDR_SCALARS) {
6363                 NDR_CHECK(ndr_pull_align(ndr, 5));
6364                 NDR_CHECK(ndr_pull_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, &r->operation));
6365                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
6366                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
6367                 if (_ptr_object_dn) {
6368                         NDR_PULL_ALLOC(ndr, r->object_dn);
6369                 } else {
6370                         r->object_dn = NULL;
6371                 }
6372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6373                 if (r->count > 10000) {
6374                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6375                 }
6376                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_spn_names));
6377                 if (_ptr_spn_names) {
6378                         NDR_PULL_ALLOC(ndr, r->spn_names);
6379                 } else {
6380                         r->spn_names = NULL;
6381                 }
6382                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6383         }
6384         if (ndr_flags & NDR_BUFFERS) {
6385                 if (r->object_dn) {
6386                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6387                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
6388                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
6389                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
6390                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
6391                                 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));
6392                         }
6393                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
6394                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
6395                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
6396                 }
6397                 if (r->spn_names) {
6398                         _mem_save_spn_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6399                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6400                         NDR_CHECK(ndr_pull_array_size(ndr, &r->spn_names));
6401                         NDR_PULL_ALLOC_N(ndr, r->spn_names, ndr_get_array_size(ndr, &r->spn_names));
6402                         _mem_save_spn_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
6403                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6404                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6405                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6406                         }
6407                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6408                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6409                         }
6410                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_1, 0);
6411                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_0, 0);
6412                 }
6413                 if (r->spn_names) {
6414                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->spn_names, r->count));
6415                 }
6416         }
6417         return NDR_ERR_SUCCESS;
6418 }
6419
6420 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6421 {
6422         uint32_t cntr_spn_names_1;
6423         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnRequest1");
6424         ndr->depth++;
6425         ndr_print_drsuapi_DsSpnOperation(ndr, "operation", r->operation);
6426         ndr_print_uint32(ndr, "unknown1", r->unknown1);
6427         ndr_print_ptr(ndr, "object_dn", r->object_dn);
6428         ndr->depth++;
6429         if (r->object_dn) {
6430                 ndr_print_string(ndr, "object_dn", r->object_dn);
6431         }
6432         ndr->depth--;
6433         ndr_print_uint32(ndr, "count", r->count);
6434         ndr_print_ptr(ndr, "spn_names", r->spn_names);
6435         ndr->depth++;
6436         if (r->spn_names) {
6437                 ndr->print(ndr, "%s: ARRAY(%d)", "spn_names", (int)r->count);
6438                 ndr->depth++;
6439                 for (cntr_spn_names_1=0;cntr_spn_names_1<r->count;cntr_spn_names_1++) {
6440                         char *idx_1=NULL;
6441                         if (asprintf(&idx_1, "[%d]", cntr_spn_names_1) != -1) {
6442                                 ndr_print_drsuapi_DsNameString(ndr, "spn_names", &r->spn_names[cntr_spn_names_1]);
6443                                 free(idx_1);
6444                         }
6445                 }
6446                 ndr->depth--;
6447         }
6448         ndr->depth--;
6449         ndr->depth--;
6450 }
6451
6452 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnRequest *r)
6453 {
6454         if (ndr_flags & NDR_SCALARS) {
6455                 int level = ndr_push_get_switch_value(ndr, r);
6456                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6457                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6458                 switch (level) {
6459                         case 1: {
6460                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6461                         break; }
6462
6463                         default:
6464                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6465                 }
6466         }
6467         if (ndr_flags & NDR_BUFFERS) {
6468                 int level = ndr_push_get_switch_value(ndr, r);
6469                 switch (level) {
6470                         case 1:
6471                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6472                         break;
6473
6474                         default:
6475                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6476                 }
6477         }
6478         return NDR_ERR_SUCCESS;
6479 }
6480
6481 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnRequest *r)
6482 {
6483         int level;
6484         int32_t _level;
6485         level = ndr_pull_get_switch_value(ndr, r);
6486         if (ndr_flags & NDR_SCALARS) {
6487                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6488                 if (_level != level) {
6489                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6490                 }
6491                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6492                 switch (level) {
6493                         case 1: {
6494                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6495                         break; }
6496
6497                         default:
6498                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6499                 }
6500         }
6501         if (ndr_flags & NDR_BUFFERS) {
6502                 switch (level) {
6503                         case 1:
6504                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6505                         break;
6506
6507                         default:
6508                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6509                 }
6510         }
6511         return NDR_ERR_SUCCESS;
6512 }
6513
6514 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnRequest *r)
6515 {
6516         int level;
6517         level = ndr_print_get_switch_value(ndr, r);
6518         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnRequest");
6519         switch (level) {
6520                 case 1:
6521                         ndr_print_drsuapi_DsWriteAccountSpnRequest1(ndr, "req1", &r->req1);
6522                 break;
6523
6524                 default:
6525                         ndr_print_bad_level(ndr, name, level);
6526         }
6527 }
6528
6529 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6530 {
6531         if (ndr_flags & NDR_SCALARS) {
6532                 NDR_CHECK(ndr_push_align(ndr, 4));
6533                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
6534                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6535         }
6536         if (ndr_flags & NDR_BUFFERS) {
6537         }
6538         return NDR_ERR_SUCCESS;
6539 }
6540
6541 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnResult1 *r)
6542 {
6543         if (ndr_flags & NDR_SCALARS) {
6544                 NDR_CHECK(ndr_pull_align(ndr, 4));
6545                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
6546                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6547         }
6548         if (ndr_flags & NDR_BUFFERS) {
6549         }
6550         return NDR_ERR_SUCCESS;
6551 }
6552
6553 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6554 {
6555         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnResult1");
6556         ndr->depth++;
6557         ndr_print_WERROR(ndr, "status", r->status);
6558         ndr->depth--;
6559 }
6560
6561 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnResult *r)
6562 {
6563         if (ndr_flags & NDR_SCALARS) {
6564                 int level = ndr_push_get_switch_value(ndr, r);
6565                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6566                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6567                 switch (level) {
6568                         case 1: {
6569                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6570                         break; }
6571
6572                         default:
6573                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6574                 }
6575         }
6576         if (ndr_flags & NDR_BUFFERS) {
6577                 int level = ndr_push_get_switch_value(ndr, r);
6578                 switch (level) {
6579                         case 1:
6580                         break;
6581
6582                         default:
6583                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6584                 }
6585         }
6586         return NDR_ERR_SUCCESS;
6587 }
6588
6589 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnResult *r)
6590 {
6591         int level;
6592         int32_t _level;
6593         level = ndr_pull_get_switch_value(ndr, r);
6594         if (ndr_flags & NDR_SCALARS) {
6595                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6596                 if (_level != level) {
6597                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6598                 }
6599                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6600                 switch (level) {
6601                         case 1: {
6602                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6603                         break; }
6604
6605                         default:
6606                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6607                 }
6608         }
6609         if (ndr_flags & NDR_BUFFERS) {
6610                 switch (level) {
6611                         case 1:
6612                         break;
6613
6614                         default:
6615                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6616                 }
6617         }
6618         return NDR_ERR_SUCCESS;
6619 }
6620
6621 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnResult *r)
6622 {
6623         int level;
6624         level = ndr_print_get_switch_value(ndr, r);
6625         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnResult");
6626         switch (level) {
6627                 case 1:
6628                         ndr_print_drsuapi_DsWriteAccountSpnResult1(ndr, "res1", &r->res1);
6629                 break;
6630
6631                 default:
6632                         ndr_print_bad_level(ndr, name, level);
6633         }
6634 }
6635
6636 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6637 {
6638         if (ndr_flags & NDR_SCALARS) {
6639                 NDR_CHECK(ndr_push_align(ndr, 5));
6640                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6641                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
6642                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->commit));
6643                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6644         }
6645         if (ndr_flags & NDR_BUFFERS) {
6646                 if (r->server_dn) {
6647                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6648                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6649                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6650                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6651                 }
6652                 if (r->domain_dn) {
6653                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6656                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_dn, ndr_charset_length(r->domain_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6657                 }
6658         }
6659         return NDR_ERR_SUCCESS;
6660 }
6661
6662 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerRequest1 *r)
6663 {
6664         uint32_t _ptr_server_dn;
6665         TALLOC_CTX *_mem_save_server_dn_0;
6666         uint32_t _ptr_domain_dn;
6667         TALLOC_CTX *_mem_save_domain_dn_0;
6668         if (ndr_flags & NDR_SCALARS) {
6669                 NDR_CHECK(ndr_pull_align(ndr, 5));
6670                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6671                 if (_ptr_server_dn) {
6672                         NDR_PULL_ALLOC(ndr, r->server_dn);
6673                 } else {
6674                         r->server_dn = NULL;
6675                 }
6676                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_dn));
6677                 if (_ptr_domain_dn) {
6678                         NDR_PULL_ALLOC(ndr, r->domain_dn);
6679                 } else {
6680                         r->domain_dn = NULL;
6681                 }
6682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->commit));
6683                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6684         }
6685         if (ndr_flags & NDR_BUFFERS) {
6686                 if (r->server_dn) {
6687                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6688                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6689                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6690                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6691                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6692                                 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));
6693                         }
6694                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6695                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6696                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6697                 }
6698                 if (r->domain_dn) {
6699                         _mem_save_domain_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6700                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_dn, 0);
6701                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_dn));
6702                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_dn));
6703                         if (ndr_get_array_length(ndr, &r->domain_dn) > ndr_get_array_size(ndr, &r->domain_dn)) {
6704                                 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));
6705                         }
6706                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t)));
6707                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t), CH_UTF16));
6708                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_dn_0, 0);
6709                 }
6710         }
6711         return NDR_ERR_SUCCESS;
6712 }
6713
6714 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6715 {
6716         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerRequest1");
6717         ndr->depth++;
6718         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6719         ndr->depth++;
6720         if (r->server_dn) {
6721                 ndr_print_string(ndr, "server_dn", r->server_dn);
6722         }
6723         ndr->depth--;
6724         ndr_print_ptr(ndr, "domain_dn", r->domain_dn);
6725         ndr->depth++;
6726         if (r->domain_dn) {
6727                 ndr_print_string(ndr, "domain_dn", r->domain_dn);
6728         }
6729         ndr->depth--;
6730         ndr_print_uint32(ndr, "commit", r->commit);
6731         ndr->depth--;
6732 }
6733
6734 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerRequest *r)
6735 {
6736         if (ndr_flags & NDR_SCALARS) {
6737                 int level = ndr_push_get_switch_value(ndr, r);
6738                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6739                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6740                 switch (level) {
6741                         case 1: {
6742                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6743                         break; }
6744
6745                         default:
6746                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6747                 }
6748         }
6749         if (ndr_flags & NDR_BUFFERS) {
6750                 int level = ndr_push_get_switch_value(ndr, r);
6751                 switch (level) {
6752                         case 1:
6753                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6754                         break;
6755
6756                         default:
6757                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6758                 }
6759         }
6760         return NDR_ERR_SUCCESS;
6761 }
6762
6763 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerRequest *r)
6764 {
6765         int level;
6766         int32_t _level;
6767         level = ndr_pull_get_switch_value(ndr, r);
6768         if (ndr_flags & NDR_SCALARS) {
6769                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6770                 if (_level != level) {
6771                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6772                 }
6773                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6774                 switch (level) {
6775                         case 1: {
6776                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6777                         break; }
6778
6779                         default:
6780                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6781                 }
6782         }
6783         if (ndr_flags & NDR_BUFFERS) {
6784                 switch (level) {
6785                         case 1:
6786                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6787                         break;
6788
6789                         default:
6790                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6791                 }
6792         }
6793         return NDR_ERR_SUCCESS;
6794 }
6795
6796 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerRequest *r)
6797 {
6798         int level;
6799         level = ndr_print_get_switch_value(ndr, r);
6800         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerRequest");
6801         switch (level) {
6802                 case 1:
6803                         ndr_print_drsuapi_DsRemoveDSServerRequest1(ndr, "req1", &r->req1);
6804                 break;
6805
6806                 default:
6807                         ndr_print_bad_level(ndr, name, level);
6808         }
6809 }
6810
6811 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerResult1 *r)
6812 {
6813         if (ndr_flags & NDR_SCALARS) {
6814                 NDR_CHECK(ndr_push_align(ndr, 4));
6815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->last_dc_in_domain));
6816                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6817         }
6818         if (ndr_flags & NDR_BUFFERS) {
6819         }
6820         return NDR_ERR_SUCCESS;
6821 }
6822
6823 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerResult1 *r)
6824 {
6825         if (ndr_flags & NDR_SCALARS) {
6826                 NDR_CHECK(ndr_pull_align(ndr, 4));
6827                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->last_dc_in_domain));
6828                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6829         }
6830         if (ndr_flags & NDR_BUFFERS) {
6831         }
6832         return NDR_ERR_SUCCESS;
6833 }
6834
6835 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerResult1 *r)
6836 {
6837         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerResult1");
6838         ndr->depth++;
6839         ndr_print_uint32(ndr, "last_dc_in_domain", r->last_dc_in_domain);
6840         ndr->depth--;
6841 }
6842
6843 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerResult *r)
6844 {
6845         if (ndr_flags & NDR_SCALARS) {
6846                 int level = ndr_push_get_switch_value(ndr, r);
6847                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6848                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6849                 switch (level) {
6850                         case 1: {
6851                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6852                         break; }
6853
6854                         default:
6855                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6856                 }
6857         }
6858         if (ndr_flags & NDR_BUFFERS) {
6859                 int level = ndr_push_get_switch_value(ndr, r);
6860                 switch (level) {
6861                         case 1:
6862                         break;
6863
6864                         default:
6865                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6866                 }
6867         }
6868         return NDR_ERR_SUCCESS;
6869 }
6870
6871 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerResult *r)
6872 {
6873         int level;
6874         int32_t _level;
6875         level = ndr_pull_get_switch_value(ndr, r);
6876         if (ndr_flags & NDR_SCALARS) {
6877                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6878                 if (_level != level) {
6879                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6880                 }
6881                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6882                 switch (level) {
6883                         case 1: {
6884                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6885                         break; }
6886
6887                         default:
6888                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6889                 }
6890         }
6891         if (ndr_flags & NDR_BUFFERS) {
6892                 switch (level) {
6893                         case 1:
6894                         break;
6895
6896                         default:
6897                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6898                 }
6899         }
6900         return NDR_ERR_SUCCESS;
6901 }
6902
6903 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerResult *r)
6904 {
6905         int level;
6906         level = ndr_print_get_switch_value(ndr, r);
6907         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerResult");
6908         switch (level) {
6909                 case 1:
6910                         ndr_print_drsuapi_DsRemoveDSServerResult1(ndr, "res1", &r->res1);
6911                 break;
6912
6913                 default:
6914                         ndr_print_bad_level(ndr, name, level);
6915         }
6916 }
6917
6918 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoRequest1 *r)
6919 {
6920         if (ndr_flags & NDR_SCALARS) {
6921                 NDR_CHECK(ndr_push_align(ndr, 5));
6922                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
6923                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
6924                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6925         }
6926         if (ndr_flags & NDR_BUFFERS) {
6927                 if (r->domain_name) {
6928                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6929                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6930                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6931                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6932                 }
6933         }
6934         return NDR_ERR_SUCCESS;
6935 }
6936
6937 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoRequest1 *r)
6938 {
6939         uint32_t _ptr_domain_name;
6940         TALLOC_CTX *_mem_save_domain_name_0;
6941         if (ndr_flags & NDR_SCALARS) {
6942                 NDR_CHECK(ndr_pull_align(ndr, 5));
6943                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
6944                 if (_ptr_domain_name) {
6945                         NDR_PULL_ALLOC(ndr, r->domain_name);
6946                 } else {
6947                         r->domain_name = NULL;
6948                 }
6949                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
6950                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6951         }
6952         if (ndr_flags & NDR_BUFFERS) {
6953                 if (r->domain_name) {
6954                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6955                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
6956                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
6957                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
6958                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
6959                                 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));
6960                         }
6961                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
6962                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
6963                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
6964                 }
6965         }
6966         return NDR_ERR_SUCCESS;
6967 }
6968
6969 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoRequest1 *r)
6970 {
6971         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoRequest1");
6972         ndr->depth++;
6973         ndr_print_ptr(ndr, "domain_name", r->domain_name);
6974         ndr->depth++;
6975         if (r->domain_name) {
6976                 ndr_print_string(ndr, "domain_name", r->domain_name);
6977         }
6978         ndr->depth--;
6979         ndr_print_int32(ndr, "level", r->level);
6980         ndr->depth--;
6981 }
6982
6983 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoRequest *r)
6984 {
6985         if (ndr_flags & NDR_SCALARS) {
6986                 int level = ndr_push_get_switch_value(ndr, r);
6987                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6988                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6989                 switch (level) {
6990                         case 1: {
6991                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6992                         break; }
6993
6994                         default:
6995                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6996                 }
6997         }
6998         if (ndr_flags & NDR_BUFFERS) {
6999                 int level = ndr_push_get_switch_value(ndr, r);
7000                 switch (level) {
7001                         case 1:
7002                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
7003                         break;
7004
7005                         default:
7006                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
7007                 }
7008         }
7009         return NDR_ERR_SUCCESS;
7010 }
7011
7012 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoRequest *r)
7013 {
7014         int level;
7015         int32_t _level;
7016         level = ndr_pull_get_switch_value(ndr, r);
7017         if (ndr_flags & NDR_SCALARS) {
7018                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
7019                 if (_level != level) {
7020                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
7021                 }
7022                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
7023                 switch (level) {
7024                         case 1: {
7025                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
7026                         break; }
7027
7028                         default:
7029                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
7030                 }
7031         }
7032         if (ndr_flags & NDR_BUFFERS) {
7033                 switch (level) {
7034                         case 1:
7035                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
7036                         break;
7037
7038                         default:
7039                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
7040                 }
7041         }
7042         return NDR_ERR_SUCCESS;
7043 }
7044
7045 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoRequest *r)
7046 {
7047         int level;
7048         level = ndr_print_get_switch_value(ndr, r);
7049         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoRequest");
7050         switch (level) {
7051                 case 1:
7052                         ndr_print_drsuapi_DsGetDCInfoRequest1(ndr, "req1", &r->req1);
7053                 break;
7054
7055                 default:
7056                         ndr_print_bad_level(ndr, name, level);
7057         }
7058 }
7059
7060 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo1 *r)
7061 {
7062         if (ndr_flags & NDR_SCALARS) {
7063                 NDR_CHECK(ndr_push_align(ndr, 5));
7064                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7065                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7066                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7067                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7068                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7070                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7071                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7072         }
7073         if (ndr_flags & NDR_BUFFERS) {
7074                 if (r->netbios_name) {
7075                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7076                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7077                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7078                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7079                 }
7080                 if (r->dns_name) {
7081                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7082                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7083                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7084                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7085                 }
7086                 if (r->site_name) {
7087                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7088                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7089                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7090                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7091                 }
7092                 if (r->computer_dn) {
7093                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7094                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7095                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7096                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7097                 }
7098                 if (r->server_dn) {
7099                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7100                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7101                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7102                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7103                 }
7104         }
7105         return NDR_ERR_SUCCESS;
7106 }
7107
7108 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo1 *r)
7109 {
7110         uint32_t _ptr_netbios_name;
7111         TALLOC_CTX *_mem_save_netbios_name_0;
7112         uint32_t _ptr_dns_name;
7113         TALLOC_CTX *_mem_save_dns_name_0;
7114         uint32_t _ptr_site_name;
7115         TALLOC_CTX *_mem_save_site_name_0;
7116         uint32_t _ptr_computer_dn;
7117         TALLOC_CTX *_mem_save_computer_dn_0;
7118         uint32_t _ptr_server_dn;
7119         TALLOC_CTX *_mem_save_server_dn_0;
7120         if (ndr_flags & NDR_SCALARS) {
7121                 NDR_CHECK(ndr_pull_align(ndr, 5));
7122                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7123                 if (_ptr_netbios_name) {
7124                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7125                 } else {
7126                         r->netbios_name = NULL;
7127                 }
7128                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7129                 if (_ptr_dns_name) {
7130                         NDR_PULL_ALLOC(ndr, r->dns_name);
7131                 } else {
7132                         r->dns_name = NULL;
7133                 }
7134                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7135                 if (_ptr_site_name) {
7136                         NDR_PULL_ALLOC(ndr, r->site_name);
7137                 } else {
7138                         r->site_name = NULL;
7139                 }
7140                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7141                 if (_ptr_computer_dn) {
7142                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7143                 } else {
7144                         r->computer_dn = NULL;
7145                 }
7146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7147                 if (_ptr_server_dn) {
7148                         NDR_PULL_ALLOC(ndr, r->server_dn);
7149                 } else {
7150                         r->server_dn = NULL;
7151                 }
7152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7154                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7155         }
7156         if (ndr_flags & NDR_BUFFERS) {
7157                 if (r->netbios_name) {
7158                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7159                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7160                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7161                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7162                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7163                                 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));
7164                         }
7165                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7166                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7168                 }
7169                 if (r->dns_name) {
7170                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7171                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7172                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7173                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7174                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7175                                 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));
7176                         }
7177                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7178                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7179                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7180                 }
7181                 if (r->site_name) {
7182                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7183                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7184                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7185                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7186                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7187                                 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));
7188                         }
7189                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7190                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7192                 }
7193                 if (r->computer_dn) {
7194                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7195                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7198                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7199                                 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));
7200                         }
7201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7204                 }
7205                 if (r->server_dn) {
7206                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7207                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7208                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7209                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7210                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7211                                 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));
7212                         }
7213                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7214                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7216                 }
7217         }
7218         return NDR_ERR_SUCCESS;
7219 }
7220
7221 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo1 *r)
7222 {
7223         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo1");
7224         ndr->depth++;
7225         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7226         ndr->depth++;
7227         if (r->netbios_name) {
7228                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7229         }
7230         ndr->depth--;
7231         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7232         ndr->depth++;
7233         if (r->dns_name) {
7234                 ndr_print_string(ndr, "dns_name", r->dns_name);
7235         }
7236         ndr->depth--;
7237         ndr_print_ptr(ndr, "site_name", r->site_name);
7238         ndr->depth++;
7239         if (r->site_name) {
7240                 ndr_print_string(ndr, "site_name", r->site_name);
7241         }
7242         ndr->depth--;
7243         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7244         ndr->depth++;
7245         if (r->computer_dn) {
7246                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7247         }
7248         ndr->depth--;
7249         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7250         ndr->depth++;
7251         if (r->server_dn) {
7252                 ndr_print_string(ndr, "server_dn", r->server_dn);
7253         }
7254         ndr->depth--;
7255         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7256         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7257         ndr->depth--;
7258 }
7259
7260 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr1 *r)
7261 {
7262         uint32_t cntr_array_1;
7263         if (ndr_flags & NDR_SCALARS) {
7264                 NDR_CHECK(ndr_push_align(ndr, 5));
7265                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7266                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7267                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7268         }
7269         if (ndr_flags & NDR_BUFFERS) {
7270                 if (r->array) {
7271                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7272                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7273                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7274                         }
7275                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7276                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7277                         }
7278                 }
7279         }
7280         return NDR_ERR_SUCCESS;
7281 }
7282
7283 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr1 *r)
7284 {
7285         uint32_t _ptr_array;
7286         uint32_t cntr_array_1;
7287         TALLOC_CTX *_mem_save_array_0;
7288         TALLOC_CTX *_mem_save_array_1;
7289         if (ndr_flags & NDR_SCALARS) {
7290                 NDR_CHECK(ndr_pull_align(ndr, 5));
7291                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7292                 if (r->count > 10000) {
7293                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7294                 }
7295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7296                 if (_ptr_array) {
7297                         NDR_PULL_ALLOC(ndr, r->array);
7298                 } else {
7299                         r->array = NULL;
7300                 }
7301                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7302         }
7303         if (ndr_flags & NDR_BUFFERS) {
7304                 if (r->array) {
7305                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7306                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7307                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7308                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7309                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7310                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7311                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7312                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7313                         }
7314                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7315                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7316                         }
7317                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7318                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7319                 }
7320                 if (r->array) {
7321                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7322                 }
7323         }
7324         return NDR_ERR_SUCCESS;
7325 }
7326
7327 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr1 *r)
7328 {
7329         uint32_t cntr_array_1;
7330         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr1");
7331         ndr->depth++;
7332         ndr_print_uint32(ndr, "count", r->count);
7333         ndr_print_ptr(ndr, "array", r->array);
7334         ndr->depth++;
7335         if (r->array) {
7336                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7337                 ndr->depth++;
7338                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7339                         char *idx_1=NULL;
7340                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7341                                 ndr_print_drsuapi_DsGetDCInfo1(ndr, "array", &r->array[cntr_array_1]);
7342                                 free(idx_1);
7343                         }
7344                 }
7345                 ndr->depth--;
7346         }
7347         ndr->depth--;
7348         ndr->depth--;
7349 }
7350
7351 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo2 *r)
7352 {
7353         if (ndr_flags & NDR_SCALARS) {
7354                 NDR_CHECK(ndr_push_align(ndr, 5));
7355                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7360                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7365                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7366                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7367                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7368                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7369                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7370         }
7371         if (ndr_flags & NDR_BUFFERS) {
7372                 if (r->netbios_name) {
7373                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7374                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7375                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7376                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7377                 }
7378                 if (r->dns_name) {
7379                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7380                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7381                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7382                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7383                 }
7384                 if (r->site_name) {
7385                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7386                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7387                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7388                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7389                 }
7390                 if (r->site_dn) {
7391                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7392                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7393                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7394                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7395                 }
7396                 if (r->computer_dn) {
7397                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7398                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7399                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7400                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7401                 }
7402                 if (r->server_dn) {
7403                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7404                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7405                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7406                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7407                 }
7408                 if (r->ntds_dn) {
7409                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7410                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7411                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7412                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7413                 }
7414         }
7415         return NDR_ERR_SUCCESS;
7416 }
7417
7418 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo2 *r)
7419 {
7420         uint32_t _ptr_netbios_name;
7421         TALLOC_CTX *_mem_save_netbios_name_0;
7422         uint32_t _ptr_dns_name;
7423         TALLOC_CTX *_mem_save_dns_name_0;
7424         uint32_t _ptr_site_name;
7425         TALLOC_CTX *_mem_save_site_name_0;
7426         uint32_t _ptr_site_dn;
7427         TALLOC_CTX *_mem_save_site_dn_0;
7428         uint32_t _ptr_computer_dn;
7429         TALLOC_CTX *_mem_save_computer_dn_0;
7430         uint32_t _ptr_server_dn;
7431         TALLOC_CTX *_mem_save_server_dn_0;
7432         uint32_t _ptr_ntds_dn;
7433         TALLOC_CTX *_mem_save_ntds_dn_0;
7434         if (ndr_flags & NDR_SCALARS) {
7435                 NDR_CHECK(ndr_pull_align(ndr, 5));
7436                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7437                 if (_ptr_netbios_name) {
7438                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7439                 } else {
7440                         r->netbios_name = NULL;
7441                 }
7442                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7443                 if (_ptr_dns_name) {
7444                         NDR_PULL_ALLOC(ndr, r->dns_name);
7445                 } else {
7446                         r->dns_name = NULL;
7447                 }
7448                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7449                 if (_ptr_site_name) {
7450                         NDR_PULL_ALLOC(ndr, r->site_name);
7451                 } else {
7452                         r->site_name = NULL;
7453                 }
7454                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7455                 if (_ptr_site_dn) {
7456                         NDR_PULL_ALLOC(ndr, r->site_dn);
7457                 } else {
7458                         r->site_dn = NULL;
7459                 }
7460                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7461                 if (_ptr_computer_dn) {
7462                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7463                 } else {
7464                         r->computer_dn = NULL;
7465                 }
7466                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7467                 if (_ptr_server_dn) {
7468                         NDR_PULL_ALLOC(ndr, r->server_dn);
7469                 } else {
7470                         r->server_dn = NULL;
7471                 }
7472                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7473                 if (_ptr_ntds_dn) {
7474                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7475                 } else {
7476                         r->ntds_dn = NULL;
7477                 }
7478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7480                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7481                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7482                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7483                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7484                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7485                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7486         }
7487         if (ndr_flags & NDR_BUFFERS) {
7488                 if (r->netbios_name) {
7489                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7490                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7491                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7492                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7493                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7494                                 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));
7495                         }
7496                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7497                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7498                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7499                 }
7500                 if (r->dns_name) {
7501                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7502                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7503                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7504                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7505                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7506                                 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));
7507                         }
7508                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7509                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7510                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7511                 }
7512                 if (r->site_name) {
7513                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7514                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7515                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7516                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7517                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7518                                 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));
7519                         }
7520                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7521                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7522                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7523                 }
7524                 if (r->site_dn) {
7525                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7526                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7527                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7528                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7529                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7530                                 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));
7531                         }
7532                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7533                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7534                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7535                 }
7536                 if (r->computer_dn) {
7537                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7538                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7539                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7540                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7541                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7542                                 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));
7543                         }
7544                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7545                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7546                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7547                 }
7548                 if (r->server_dn) {
7549                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7550                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7551                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7552                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7553                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7554                                 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));
7555                         }
7556                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7557                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7558                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7559                 }
7560                 if (r->ntds_dn) {
7561                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7562                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7563                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7564                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7565                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7566                                 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));
7567                         }
7568                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7569                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7570                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7571                 }
7572         }
7573         return NDR_ERR_SUCCESS;
7574 }
7575
7576 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo2 *r)
7577 {
7578         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo2");
7579         ndr->depth++;
7580         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7581         ndr->depth++;
7582         if (r->netbios_name) {
7583                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7584         }
7585         ndr->depth--;
7586         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7587         ndr->depth++;
7588         if (r->dns_name) {
7589                 ndr_print_string(ndr, "dns_name", r->dns_name);
7590         }
7591         ndr->depth--;
7592         ndr_print_ptr(ndr, "site_name", r->site_name);
7593         ndr->depth++;
7594         if (r->site_name) {
7595                 ndr_print_string(ndr, "site_name", r->site_name);
7596         }
7597         ndr->depth--;
7598         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7599         ndr->depth++;
7600         if (r->site_dn) {
7601                 ndr_print_string(ndr, "site_dn", r->site_dn);
7602         }
7603         ndr->depth--;
7604         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7605         ndr->depth++;
7606         if (r->computer_dn) {
7607                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7608         }
7609         ndr->depth--;
7610         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7611         ndr->depth++;
7612         if (r->server_dn) {
7613                 ndr_print_string(ndr, "server_dn", r->server_dn);
7614         }
7615         ndr->depth--;
7616         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7617         ndr->depth++;
7618         if (r->ntds_dn) {
7619                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7620         }
7621         ndr->depth--;
7622         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7623         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7624         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7625         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7626         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7627         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7628         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7629         ndr->depth--;
7630 }
7631
7632 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr2 *r)
7633 {
7634         uint32_t cntr_array_1;
7635         if (ndr_flags & NDR_SCALARS) {
7636                 NDR_CHECK(ndr_push_align(ndr, 5));
7637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7638                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7639                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7640         }
7641         if (ndr_flags & NDR_BUFFERS) {
7642                 if (r->array) {
7643                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7644                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7645                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7646                         }
7647                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7648                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7649                         }
7650                 }
7651         }
7652         return NDR_ERR_SUCCESS;
7653 }
7654
7655 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr2 *r)
7656 {
7657         uint32_t _ptr_array;
7658         uint32_t cntr_array_1;
7659         TALLOC_CTX *_mem_save_array_0;
7660         TALLOC_CTX *_mem_save_array_1;
7661         if (ndr_flags & NDR_SCALARS) {
7662                 NDR_CHECK(ndr_pull_align(ndr, 5));
7663                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7664                 if (r->count > 10000) {
7665                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7666                 }
7667                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7668                 if (_ptr_array) {
7669                         NDR_PULL_ALLOC(ndr, r->array);
7670                 } else {
7671                         r->array = NULL;
7672                 }
7673                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7674         }
7675         if (ndr_flags & NDR_BUFFERS) {
7676                 if (r->array) {
7677                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7678                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7679                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7680                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7681                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7682                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7683                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7684                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7685                         }
7686                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7687                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7688                         }
7689                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7690                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7691                 }
7692                 if (r->array) {
7693                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7694                 }
7695         }
7696         return NDR_ERR_SUCCESS;
7697 }
7698
7699 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr2 *r)
7700 {
7701         uint32_t cntr_array_1;
7702         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr2");
7703         ndr->depth++;
7704         ndr_print_uint32(ndr, "count", r->count);
7705         ndr_print_ptr(ndr, "array", r->array);
7706         ndr->depth++;
7707         if (r->array) {
7708                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7709                 ndr->depth++;
7710                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7711                         char *idx_1=NULL;
7712                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7713                                 ndr_print_drsuapi_DsGetDCInfo2(ndr, "array", &r->array[cntr_array_1]);
7714                                 free(idx_1);
7715                         }
7716                 }
7717                 ndr->depth--;
7718         }
7719         ndr->depth--;
7720         ndr->depth--;
7721 }
7722
7723 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo3 *r)
7724 {
7725         if (ndr_flags & NDR_SCALARS) {
7726                 NDR_CHECK(ndr_push_align(ndr, 5));
7727                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7728                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7729                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7730                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7731                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7732                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7733                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7734                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_rodc));
7738                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7739                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7740                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7741                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7742                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7743         }
7744         if (ndr_flags & NDR_BUFFERS) {
7745                 if (r->netbios_name) {
7746                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7747                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7748                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7749                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7750                 }
7751                 if (r->dns_name) {
7752                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7753                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7754                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7755                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7756                 }
7757                 if (r->site_name) {
7758                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7759                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7760                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7761                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7762                 }
7763                 if (r->site_dn) {
7764                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7765                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7766                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7767                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7768                 }
7769                 if (r->computer_dn) {
7770                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7771                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7772                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7773                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7774                 }
7775                 if (r->server_dn) {
7776                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7777                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7778                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7779                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7780                 }
7781                 if (r->ntds_dn) {
7782                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7783                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7784                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7785                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7786                 }
7787         }
7788         return NDR_ERR_SUCCESS;
7789 }
7790
7791 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo3 *r)
7792 {
7793         uint32_t _ptr_netbios_name;
7794         TALLOC_CTX *_mem_save_netbios_name_0;
7795         uint32_t _ptr_dns_name;
7796         TALLOC_CTX *_mem_save_dns_name_0;
7797         uint32_t _ptr_site_name;
7798         TALLOC_CTX *_mem_save_site_name_0;
7799         uint32_t _ptr_site_dn;
7800         TALLOC_CTX *_mem_save_site_dn_0;
7801         uint32_t _ptr_computer_dn;
7802         TALLOC_CTX *_mem_save_computer_dn_0;
7803         uint32_t _ptr_server_dn;
7804         TALLOC_CTX *_mem_save_server_dn_0;
7805         uint32_t _ptr_ntds_dn;
7806         TALLOC_CTX *_mem_save_ntds_dn_0;
7807         if (ndr_flags & NDR_SCALARS) {
7808                 NDR_CHECK(ndr_pull_align(ndr, 5));
7809                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7810                 if (_ptr_netbios_name) {
7811                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7812                 } else {
7813                         r->netbios_name = NULL;
7814                 }
7815                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7816                 if (_ptr_dns_name) {
7817                         NDR_PULL_ALLOC(ndr, r->dns_name);
7818                 } else {
7819                         r->dns_name = NULL;
7820                 }
7821                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7822                 if (_ptr_site_name) {
7823                         NDR_PULL_ALLOC(ndr, r->site_name);
7824                 } else {
7825                         r->site_name = NULL;
7826                 }
7827                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7828                 if (_ptr_site_dn) {
7829                         NDR_PULL_ALLOC(ndr, r->site_dn);
7830                 } else {
7831                         r->site_dn = NULL;
7832                 }
7833                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7834                 if (_ptr_computer_dn) {
7835                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7836                 } else {
7837                         r->computer_dn = NULL;
7838                 }
7839                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7840                 if (_ptr_server_dn) {
7841                         NDR_PULL_ALLOC(ndr, r->server_dn);
7842                 } else {
7843                         r->server_dn = NULL;
7844                 }
7845                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7846                 if (_ptr_ntds_dn) {
7847                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7848                 } else {
7849                         r->ntds_dn = NULL;
7850                 }
7851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7852                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7853                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_rodc));
7855                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7856                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7857                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7858                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7859                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7860         }
7861         if (ndr_flags & NDR_BUFFERS) {
7862                 if (r->netbios_name) {
7863                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7864                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7865                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7866                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7867                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7868                                 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));
7869                         }
7870                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7871                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7872                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7873                 }
7874                 if (r->dns_name) {
7875                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7876                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7877                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7878                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7879                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7880                                 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));
7881                         }
7882                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7883                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7884                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7885                 }
7886                 if (r->site_name) {
7887                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7888                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7889                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7890                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7891                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7892                                 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));
7893                         }
7894                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7895                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7896                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7897                 }
7898                 if (r->site_dn) {
7899                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7900                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7901                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7902                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7903                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7904                                 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));
7905                         }
7906                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7907                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7908                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7909                 }
7910                 if (r->computer_dn) {
7911                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7912                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7913                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7914                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7915                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7916                                 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));
7917                         }
7918                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7919                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7920                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7921                 }
7922                 if (r->server_dn) {
7923                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7924                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7925                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7926                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7927                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7928                                 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));
7929                         }
7930                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7931                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7932                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7933                 }
7934                 if (r->ntds_dn) {
7935                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7936                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7937                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7938                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7939                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7940                                 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));
7941                         }
7942                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7943                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7944                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7945                 }
7946         }
7947         return NDR_ERR_SUCCESS;
7948 }
7949
7950 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo3 *r)
7951 {
7952         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo3");
7953         ndr->depth++;
7954         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7955         ndr->depth++;
7956         if (r->netbios_name) {
7957                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7958         }
7959         ndr->depth--;
7960         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7961         ndr->depth++;
7962         if (r->dns_name) {
7963                 ndr_print_string(ndr, "dns_name", r->dns_name);
7964         }
7965         ndr->depth--;
7966         ndr_print_ptr(ndr, "site_name", r->site_name);
7967         ndr->depth++;
7968         if (r->site_name) {
7969                 ndr_print_string(ndr, "site_name", r->site_name);
7970         }
7971         ndr->depth--;
7972         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7973         ndr->depth++;
7974         if (r->site_dn) {
7975                 ndr_print_string(ndr, "site_dn", r->site_dn);
7976         }
7977         ndr->depth--;
7978         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7979         ndr->depth++;
7980         if (r->computer_dn) {
7981                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7982         }
7983         ndr->depth--;
7984         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7985         ndr->depth++;
7986         if (r->server_dn) {
7987                 ndr_print_string(ndr, "server_dn", r->server_dn);
7988         }
7989         ndr->depth--;
7990         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7991         ndr->depth++;
7992         if (r->ntds_dn) {
7993                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7994         }
7995         ndr->depth--;
7996         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7997         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7998         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7999         ndr_print_uint32(ndr, "is_rodc", r->is_rodc);
8000         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
8001         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
8002         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
8003         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
8004         ndr->depth--;
8005 }
8006
8007 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr3 *r)
8008 {
8009         uint32_t cntr_array_1;
8010         if (ndr_flags & NDR_SCALARS) {
8011                 NDR_CHECK(ndr_push_align(ndr, 5));
8012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8013                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
8014                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8015         }
8016         if (ndr_flags & NDR_BUFFERS) {
8017                 if (r->array) {
8018                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
8019                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8020                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8021                         }
8022                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8023                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8024                         }
8025                 }
8026         }
8027         return NDR_ERR_SUCCESS;
8028 }
8029
8030 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr3 *r)
8031 {
8032         uint32_t _ptr_array;
8033         uint32_t cntr_array_1;
8034         TALLOC_CTX *_mem_save_array_0;
8035         TALLOC_CTX *_mem_save_array_1;
8036         if (ndr_flags & NDR_SCALARS) {
8037                 NDR_CHECK(ndr_pull_align(ndr, 5));
8038                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8039                 if (r->count > 10000) {
8040                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8041                 }
8042                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
8043                 if (_ptr_array) {
8044                         NDR_PULL_ALLOC(ndr, r->array);
8045                 } else {
8046                         r->array = NULL;
8047                 }
8048                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8049         }
8050         if (ndr_flags & NDR_BUFFERS) {
8051                 if (r->array) {
8052                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
8053                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8054                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
8055                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
8056                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
8057                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8058                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8059                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8060                         }
8061                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8062                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8063                         }
8064                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
8065                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
8066                 }
8067                 if (r->array) {
8068                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
8069                 }
8070         }
8071         return NDR_ERR_SUCCESS;
8072 }
8073
8074 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr3 *r)
8075 {
8076         uint32_t cntr_array_1;
8077         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr3");
8078         ndr->depth++;
8079         ndr_print_uint32(ndr, "count", r->count);
8080         ndr_print_ptr(ndr, "array", r->array);
8081         ndr->depth++;
8082         if (r->array) {
8083                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
8084                 ndr->depth++;
8085                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
8086                         char *idx_1=NULL;
8087                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8088                                 ndr_print_drsuapi_DsGetDCInfo3(ndr, "array", &r->array[cntr_array_1]);
8089                                 free(idx_1);
8090                         }
8091                 }
8092                 ndr->depth--;
8093         }
8094         ndr->depth--;
8095         ndr->depth--;
8096 }
8097
8098 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnection01 *r)
8099 {
8100         if (ndr_flags & NDR_SCALARS) {
8101                 NDR_CHECK(ndr_push_align(ndr, 5));
8102                 {
8103                         uint32_t _flags_save_ipv4address = ndr->flags;
8104                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
8105                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
8106                         ndr->flags = _flags_save_ipv4address;
8107                 }
8108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8109                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connection_time));
8110                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
8111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
8112                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
8113                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
8114                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8115         }
8116         if (ndr_flags & NDR_BUFFERS) {
8117                 if (r->client_account) {
8118                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
8119                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8120                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
8121                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_account, ndr_charset_length(r->client_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8122                 }
8123         }
8124         return NDR_ERR_SUCCESS;
8125 }
8126
8127 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnection01 *r)
8128 {
8129         uint32_t _ptr_client_account;
8130         TALLOC_CTX *_mem_save_client_account_0;
8131         if (ndr_flags & NDR_SCALARS) {
8132                 NDR_CHECK(ndr_pull_align(ndr, 5));
8133                 {
8134                         uint32_t _flags_save_ipv4address = ndr->flags;
8135                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
8136                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
8137                         ndr->flags = _flags_save_ipv4address;
8138                 }
8139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8140                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connection_time));
8141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
8142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
8143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
8144                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_account));
8145                 if (_ptr_client_account) {
8146                         NDR_PULL_ALLOC(ndr, r->client_account);
8147                 } else {
8148                         r->client_account = NULL;
8149                 }
8150                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8151         }
8152         if (ndr_flags & NDR_BUFFERS) {
8153                 if (r->client_account) {
8154                         _mem_save_client_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8155                         NDR_PULL_SET_MEM_CTX(ndr, r->client_account, 0);
8156                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_account));
8157                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_account));
8158                         if (ndr_get_array_length(ndr, &r->client_account) > ndr_get_array_size(ndr, &r->client_account)) {
8159                                 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));
8160                         }
8161                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t)));
8162                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t), CH_UTF16));
8163                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_account_0, 0);
8164                 }
8165         }
8166         return NDR_ERR_SUCCESS;
8167 }
8168
8169 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnection01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnection01 *r)
8170 {
8171         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnection01");
8172         ndr->depth++;
8173         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
8174         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8175         ndr_print_uint32(ndr, "connection_time", r->connection_time);
8176         ndr_print_uint32(ndr, "unknown4", r->unknown4);
8177         ndr_print_uint32(ndr, "unknown5", r->unknown5);
8178         ndr_print_uint32(ndr, "unknown6", r->unknown6);
8179         ndr_print_ptr(ndr, "client_account", r->client_account);
8180         ndr->depth++;
8181         if (r->client_account) {
8182                 ndr_print_string(ndr, "client_account", r->client_account);
8183         }
8184         ndr->depth--;
8185         ndr->depth--;
8186 }
8187
8188 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8189 {
8190         uint32_t cntr_array_1;
8191         if (ndr_flags & NDR_SCALARS) {
8192                 NDR_CHECK(ndr_push_align(ndr, 5));
8193                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8194                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
8195                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8196         }
8197         if (ndr_flags & NDR_BUFFERS) {
8198                 if (r->array) {
8199                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
8200                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8201                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8202                         }
8203                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8204                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8205                         }
8206                 }
8207         }
8208         return NDR_ERR_SUCCESS;
8209 }
8210
8211 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnectionCtr01 *r)
8212 {
8213         uint32_t _ptr_array;
8214         uint32_t cntr_array_1;
8215         TALLOC_CTX *_mem_save_array_0;
8216         TALLOC_CTX *_mem_save_array_1;
8217         if (ndr_flags & NDR_SCALARS) {
8218                 NDR_CHECK(ndr_pull_align(ndr, 5));
8219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8220                 if (r->count > 10000) {
8221                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8222                 }
8223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
8224                 if (_ptr_array) {
8225                         NDR_PULL_ALLOC(ndr, r->array);
8226                 } else {
8227                         r->array = NULL;
8228                 }
8229                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8230         }
8231         if (ndr_flags & NDR_BUFFERS) {
8232                 if (r->array) {
8233                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
8234                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8235                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
8236                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
8237                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
8238                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8239                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8240                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8241                         }
8242                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8243                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8244                         }
8245                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
8246                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
8247                 }
8248                 if (r->array) {
8249                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
8250                 }
8251         }
8252         return NDR_ERR_SUCCESS;
8253 }
8254
8255 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnectionCtr01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8256 {
8257         uint32_t cntr_array_1;
8258         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnectionCtr01");
8259         ndr->depth++;
8260         ndr_print_uint32(ndr, "count", r->count);
8261         ndr_print_ptr(ndr, "array", r->array);
8262         ndr->depth++;
8263         if (r->array) {
8264                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
8265                 ndr->depth++;
8266                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
8267                         char *idx_1=NULL;
8268                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8269                                 ndr_print_drsuapi_DsGetDCConnection01(ndr, "array", &r->array[cntr_array_1]);
8270                                 free(idx_1);
8271                         }
8272                 }
8273                 ndr->depth--;
8274         }
8275         ndr->depth--;
8276         ndr->depth--;
8277 }
8278
8279 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoCtr *r)
8280 {
8281         if (ndr_flags & NDR_SCALARS) {
8282                 int level = ndr_push_get_switch_value(ndr, r);
8283                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8284                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8285                 switch (level) {
8286                         case DRSUAPI_DC_INFO_CTR_1: {
8287                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8288                         break; }
8289
8290                         case DRSUAPI_DC_INFO_CTR_2: {
8291                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8292                         break; }
8293
8294                         case DRSUAPI_DC_INFO_CTR_3: {
8295                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8296                         break; }
8297
8298                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8299                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8300                         break; }
8301
8302                         default:
8303                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8304                 }
8305         }
8306         if (ndr_flags & NDR_BUFFERS) {
8307                 int level = ndr_push_get_switch_value(ndr, r);
8308                 switch (level) {
8309                         case DRSUAPI_DC_INFO_CTR_1:
8310                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8311                         break;
8312
8313                         case DRSUAPI_DC_INFO_CTR_2:
8314                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8315                         break;
8316
8317                         case DRSUAPI_DC_INFO_CTR_3:
8318                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8319                         break;
8320
8321                         case DRSUAPI_DC_CONNECTION_CTR_01:
8322                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8323                         break;
8324
8325                         default:
8326                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8327                 }
8328         }
8329         return NDR_ERR_SUCCESS;
8330 }
8331
8332 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoCtr *r)
8333 {
8334         int level;
8335         int32_t _level;
8336         level = ndr_pull_get_switch_value(ndr, r);
8337         if (ndr_flags & NDR_SCALARS) {
8338                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8339                 if (_level != level) {
8340                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8341                 }
8342                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8343                 switch (level) {
8344                         case DRSUAPI_DC_INFO_CTR_1: {
8345                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8346                         break; }
8347
8348                         case DRSUAPI_DC_INFO_CTR_2: {
8349                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8350                         break; }
8351
8352                         case DRSUAPI_DC_INFO_CTR_3: {
8353                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8354                         break; }
8355
8356                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8357                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8358                         break; }
8359
8360                         default:
8361                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8362                 }
8363         }
8364         if (ndr_flags & NDR_BUFFERS) {
8365                 switch (level) {
8366                         case DRSUAPI_DC_INFO_CTR_1:
8367                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8368                         break;
8369
8370                         case DRSUAPI_DC_INFO_CTR_2:
8371                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8372                         break;
8373
8374                         case DRSUAPI_DC_INFO_CTR_3:
8375                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8376                         break;
8377
8378                         case DRSUAPI_DC_CONNECTION_CTR_01:
8379                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8380                         break;
8381
8382                         default:
8383                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8384                 }
8385         }
8386         return NDR_ERR_SUCCESS;
8387 }
8388
8389 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoCtr *r)
8390 {
8391         int level;
8392         level = ndr_print_get_switch_value(ndr, r);
8393         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoCtr");
8394         switch (level) {
8395                 case DRSUAPI_DC_INFO_CTR_1:
8396                         ndr_print_drsuapi_DsGetDCInfoCtr1(ndr, "ctr1", &r->ctr1);
8397                 break;
8398
8399                 case DRSUAPI_DC_INFO_CTR_2:
8400                         ndr_print_drsuapi_DsGetDCInfoCtr2(ndr, "ctr2", &r->ctr2);
8401                 break;
8402
8403                 case DRSUAPI_DC_INFO_CTR_3:
8404                         ndr_print_drsuapi_DsGetDCInfoCtr3(ndr, "ctr3", &r->ctr3);
8405                 break;
8406
8407                 case DRSUAPI_DC_CONNECTION_CTR_01:
8408                         ndr_print_drsuapi_DsGetDCConnectionCtr01(ndr, "ctr01", &r->ctr01);
8409                 break;
8410
8411                 default:
8412                         ndr_print_bad_level(ndr, name, level);
8413         }
8414 }
8415
8416 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItem *r)
8417 {
8418         if (ndr_flags & NDR_SCALARS) {
8419                 NDR_CHECK(ndr_push_align(ndr, 5));
8420                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
8421                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8422                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8423         }
8424         if (ndr_flags & NDR_BUFFERS) {
8425                 if (r->next_object) {
8426                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8427                 }
8428                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8429         }
8430         return NDR_ERR_SUCCESS;
8431 }
8432
8433 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItem *r)
8434 {
8435         uint32_t _ptr_next_object;
8436         TALLOC_CTX *_mem_save_next_object_0;
8437         if (ndr_flags & NDR_SCALARS) {
8438                 NDR_CHECK(ndr_pull_align(ndr, 5));
8439                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
8440                 if (_ptr_next_object) {
8441                         NDR_PULL_ALLOC(ndr, r->next_object);
8442                 } else {
8443                         r->next_object = NULL;
8444                 }
8445                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8446                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8447         }
8448         if (ndr_flags & NDR_BUFFERS) {
8449                 if (r->next_object) {
8450                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
8451                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
8452                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8453                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
8454                 }
8455                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8456         }
8457         return NDR_ERR_SUCCESS;
8458 }
8459
8460 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryRequest2 *r)
8461 {
8462         if (ndr_flags & NDR_SCALARS) {
8463                 NDR_CHECK(ndr_push_align(ndr, 5));
8464                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8465                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8466         }
8467         if (ndr_flags & NDR_BUFFERS) {
8468                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8469         }
8470         return NDR_ERR_SUCCESS;
8471 }
8472
8473 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryRequest2 *r)
8474 {
8475         if (ndr_flags & NDR_SCALARS) {
8476                 NDR_CHECK(ndr_pull_align(ndr, 5));
8477                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8478                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8479         }
8480         if (ndr_flags & NDR_BUFFERS) {
8481                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8482         }
8483         return NDR_ERR_SUCCESS;
8484 }
8485
8486 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryRequest2 *r)
8487 {
8488         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryRequest2");
8489         ndr->depth++;
8490         ndr_print_drsuapi_DsReplicaObjectListItem(ndr, "first_object", &r->first_object);
8491         ndr->depth--;
8492 }
8493
8494 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryRequest *r)
8495 {
8496         if (ndr_flags & NDR_SCALARS) {
8497                 int level = ndr_push_get_switch_value(ndr, r);
8498                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8499                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8500                 switch (level) {
8501                         case 2: {
8502                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8503                         break; }
8504
8505                         default:
8506                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8507                 }
8508         }
8509         if (ndr_flags & NDR_BUFFERS) {
8510                 int level = ndr_push_get_switch_value(ndr, r);
8511                 switch (level) {
8512                         case 2:
8513                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8514                         break;
8515
8516                         default:
8517                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8518                 }
8519         }
8520         return NDR_ERR_SUCCESS;
8521 }
8522
8523 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryRequest *r)
8524 {
8525         int level;
8526         int32_t _level;
8527         level = ndr_pull_get_switch_value(ndr, r);
8528         if (ndr_flags & NDR_SCALARS) {
8529                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8530                 if (_level != level) {
8531                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8532                 }
8533                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8534                 switch (level) {
8535                         case 2: {
8536                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8537                         break; }
8538
8539                         default:
8540                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8541                 }
8542         }
8543         if (ndr_flags & NDR_BUFFERS) {
8544                 switch (level) {
8545                         case 2:
8546                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8547                         break;
8548
8549                         default:
8550                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8551                 }
8552         }
8553         return NDR_ERR_SUCCESS;
8554 }
8555
8556 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryRequest *r)
8557 {
8558         int level;
8559         level = ndr_print_get_switch_value(ndr, r);
8560         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryRequest");
8561         switch (level) {
8562                 case 2:
8563                         ndr_print_drsuapi_DsAddEntryRequest2(ndr, "req2", &r->req2);
8564                 break;
8565
8566                 default:
8567                         ndr_print_bad_level(ndr, name, level);
8568         }
8569 }
8570
8571 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfoX *r)
8572 {
8573         if (ndr_flags & NDR_SCALARS) {
8574                 NDR_CHECK(ndr_push_align(ndr, 4));
8575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8576                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8577                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8578                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
8579                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8580         }
8581         if (ndr_flags & NDR_BUFFERS) {
8582         }
8583         return NDR_ERR_SUCCESS;
8584 }
8585
8586 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfoX *r)
8587 {
8588         if (ndr_flags & NDR_SCALARS) {
8589                 NDR_CHECK(ndr_pull_align(ndr, 4));
8590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8591                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8593                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
8594                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8595         }
8596         if (ndr_flags & NDR_BUFFERS) {
8597         }
8598         return NDR_ERR_SUCCESS;
8599 }
8600
8601 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfoX(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfoX *r)
8602 {
8603         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfoX");
8604         ndr->depth++;
8605         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8606         ndr_print_WERROR(ndr, "status", r->status);
8607         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8608         ndr_print_uint16(ndr, "unknown3", r->unknown3);
8609         ndr->depth--;
8610 }
8611
8612 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8613 {
8614         if (ndr_flags & NDR_SCALARS) {
8615                 NDR_CHECK(ndr_push_align(ndr, 5));
8616                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
8618                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8619         }
8620         if (ndr_flags & NDR_BUFFERS) {
8621                 if (r->data) {
8622                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size));
8623                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
8624                 }
8625         }
8626         return NDR_ERR_SUCCESS;
8627 }
8628
8629 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8630 {
8631         uint32_t _ptr_data;
8632         TALLOC_CTX *_mem_save_data_0;
8633         if (ndr_flags & NDR_SCALARS) {
8634                 NDR_CHECK(ndr_pull_align(ndr, 5));
8635                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8636                 if (r->size > 10485760) {
8637                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8638                 }
8639                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
8640                 if (_ptr_data) {
8641                         NDR_PULL_ALLOC(ndr, r->data);
8642                 } else {
8643                         r->data = NULL;
8644                 }
8645                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8646         }
8647         if (ndr_flags & NDR_BUFFERS) {
8648                 if (r->data) {
8649                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
8650                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
8651                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
8652                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
8653                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
8654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
8655                 }
8656                 if (r->data) {
8657                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
8658                 }
8659         }
8660         return NDR_ERR_SUCCESS;
8661 }
8662
8663 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8664 {
8665         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraErrorBuffer");
8666         ndr->depth++;
8667         ndr_print_uint32(ndr, "size", r->size);
8668         ndr_print_ptr(ndr, "data", r->data);
8669         ndr->depth++;
8670         if (r->data) {
8671                 ndr_print_array_uint8(ndr, "data", r->data, r->size);
8672         }
8673         ndr->depth--;
8674         ndr->depth--;
8675 }
8676
8677 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraError1 *r)
8678 {
8679         if (ndr_flags & NDR_SCALARS) {
8680                 NDR_CHECK(ndr_push_align(ndr, 5));
8681                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8682                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
8683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8684                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8685                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8686         }
8687         if (ndr_flags & NDR_BUFFERS) {
8688                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8689         }
8690         return NDR_ERR_SUCCESS;
8691 }
8692
8693 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraError1 *r)
8694 {
8695         if (ndr_flags & NDR_SCALARS) {
8696                 NDR_CHECK(ndr_pull_align(ndr, 5));
8697                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8698                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
8699                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8700                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8701                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8702         }
8703         if (ndr_flags & NDR_BUFFERS) {
8704                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8705         }
8706         return NDR_ERR_SUCCESS;
8707 }
8708
8709 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraError1 *r)
8710 {
8711         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraError1");
8712         ndr->depth++;
8713         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8714         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
8715         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8716         ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(ndr, "buffer", &r->buffer);
8717         ndr->depth--;
8718 }
8719
8720 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8721 {
8722         if (ndr_flags & NDR_SCALARS) {
8723                 NDR_CHECK(ndr_push_align(ndr, 5));
8724                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
8725                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8726                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8727         }
8728         if (ndr_flags & NDR_BUFFERS) {
8729                 if (r->next) {
8730                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8731                 }
8732                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8733         }
8734         return NDR_ERR_SUCCESS;
8735 }
8736
8737 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorListItem1 *r)
8738 {
8739         uint32_t _ptr_next;
8740         TALLOC_CTX *_mem_save_next_0;
8741         if (ndr_flags & NDR_SCALARS) {
8742                 NDR_CHECK(ndr_pull_align(ndr, 5));
8743                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
8744                 if (_ptr_next) {
8745                         NDR_PULL_ALLOC(ndr, r->next);
8746                 } else {
8747                         r->next = NULL;
8748                 }
8749                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8750                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8751         }
8752         if (ndr_flags & NDR_BUFFERS) {
8753                 if (r->next) {
8754                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
8755                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
8756                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8757                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
8758                 }
8759                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8760         }
8761         return NDR_ERR_SUCCESS;
8762 }
8763
8764 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorListItem1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8765 {
8766         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorListItem1");
8767         ndr->depth++;
8768         ndr_print_ptr(ndr, "next", r->next);
8769         ndr->depth++;
8770         if (r->next) {
8771                 ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "next", r->next);
8772         }
8773         ndr->depth--;
8774         ndr_print_drsuapi_DsAddEntryExtraError1(ndr, "error", &r->error);
8775         ndr->depth--;
8776 }
8777
8778 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8779 {
8780         if (ndr_flags & NDR_SCALARS) {
8781                 NDR_CHECK(ndr_push_align(ndr, 5));
8782                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8783                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8784                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8785                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8786         }
8787         if (ndr_flags & NDR_BUFFERS) {
8788                 if (r->id) {
8789                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8790                 }
8791                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8792         }
8793         return NDR_ERR_SUCCESS;
8794 }
8795
8796 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfo1 *r)
8797 {
8798         uint32_t _ptr_id;
8799         TALLOC_CTX *_mem_save_id_0;
8800         if (ndr_flags & NDR_SCALARS) {
8801                 NDR_CHECK(ndr_pull_align(ndr, 5));
8802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8803                 if (_ptr_id) {
8804                         NDR_PULL_ALLOC(ndr, r->id);
8805                 } else {
8806                         r->id = NULL;
8807                 }
8808                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8809                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8810                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8811         }
8812         if (ndr_flags & NDR_BUFFERS) {
8813                 if (r->id) {
8814                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8815                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8816                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8817                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8818                 }
8819                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8820         }
8821         return NDR_ERR_SUCCESS;
8822 }
8823
8824 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8825 {
8826         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfo1");
8827         ndr->depth++;
8828         ndr_print_ptr(ndr, "id", r->id);
8829         ndr->depth++;
8830         if (r->id) {
8831                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8832         }
8833         ndr->depth--;
8834         ndr_print_WERROR(ndr, "status", r->status);
8835         ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "first", &r->first);
8836         ndr->depth--;
8837 }
8838
8839 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryErrorInfo *r)
8840 {
8841         if (ndr_flags & NDR_SCALARS) {
8842                 int level = ndr_push_get_switch_value(ndr, r);
8843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8844                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8845                 switch (level) {
8846                         case 1: {
8847                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8848                         break; }
8849
8850                         case 4: {
8851                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8852                         break; }
8853
8854                         case 5: {
8855                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8856                         break; }
8857
8858                         case 6: {
8859                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8860                         break; }
8861
8862                         case 7: {
8863                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8864                         break; }
8865
8866                         default:
8867                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8868                 }
8869         }
8870         if (ndr_flags & NDR_BUFFERS) {
8871                 int level = ndr_push_get_switch_value(ndr, r);
8872                 switch (level) {
8873                         case 1:
8874                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8875                         break;
8876
8877                         case 4:
8878                         break;
8879
8880                         case 5:
8881                         break;
8882
8883                         case 6:
8884                         break;
8885
8886                         case 7:
8887                         break;
8888
8889                         default:
8890                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8891                 }
8892         }
8893         return NDR_ERR_SUCCESS;
8894 }
8895
8896 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryErrorInfo *r)
8897 {
8898         int level;
8899         uint32_t _level;
8900         level = ndr_pull_get_switch_value(ndr, r);
8901         if (ndr_flags & NDR_SCALARS) {
8902                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8903                 if (_level != level) {
8904                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8905                 }
8906                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8907                 switch (level) {
8908                         case 1: {
8909                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8910                         break; }
8911
8912                         case 4: {
8913                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8914                         break; }
8915
8916                         case 5: {
8917                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8918                         break; }
8919
8920                         case 6: {
8921                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8922                         break; }
8923
8924                         case 7: {
8925                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8926                         break; }
8927
8928                         default:
8929                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8930                 }
8931         }
8932         if (ndr_flags & NDR_BUFFERS) {
8933                 switch (level) {
8934                         case 1:
8935                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8936                         break;
8937
8938                         case 4:
8939                         break;
8940
8941                         case 5:
8942                         break;
8943
8944                         case 6:
8945                         break;
8946
8947                         case 7:
8948                         break;
8949
8950                         default:
8951                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8952                 }
8953         }
8954         return NDR_ERR_SUCCESS;
8955 }
8956
8957 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryErrorInfo *r)
8958 {
8959         int level;
8960         level = ndr_print_get_switch_value(ndr, r);
8961         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryErrorInfo");
8962         switch (level) {
8963                 case 1:
8964                         ndr_print_drsuapi_DsAddEntryErrorInfo1(ndr, "error1", &r->error1);
8965                 break;
8966
8967                 case 4:
8968                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8969                 break;
8970
8971                 case 5:
8972                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8973                 break;
8974
8975                 case 6:
8976                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8977                 break;
8978
8979                 case 7:
8980                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8981                 break;
8982
8983                 default:
8984                         ndr_print_bad_level(ndr, name, level);
8985         }
8986 }
8987
8988 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryError1 *r)
8989 {
8990         if (ndr_flags & NDR_SCALARS) {
8991                 NDR_CHECK(ndr_push_align(ndr, 5));
8992                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8994                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
8995                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8996         }
8997         if (ndr_flags & NDR_BUFFERS) {
8998                 if (r->info) {
8999                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->info, r->level));
9000                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
9001                 }
9002         }
9003         return NDR_ERR_SUCCESS;
9004 }
9005
9006 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryError1 *r)
9007 {
9008         uint32_t _ptr_info;
9009         TALLOC_CTX *_mem_save_info_0;
9010         if (ndr_flags & NDR_SCALARS) {
9011                 NDR_CHECK(ndr_pull_align(ndr, 5));
9012                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
9013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9014                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9015                 if (_ptr_info) {
9016                         NDR_PULL_ALLOC(ndr, r->info);
9017                 } else {
9018                         r->info = NULL;
9019                 }
9020                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9021         }
9022         if (ndr_flags & NDR_BUFFERS) {
9023                 if (r->info) {
9024                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9025                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
9026                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->info, r->level));
9027                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
9028                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9029                 }
9030         }
9031         return NDR_ERR_SUCCESS;
9032 }
9033
9034 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryError1 *r)
9035 {
9036         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryError1");
9037         ndr->depth++;
9038         ndr_print_WERROR(ndr, "status", r->status);
9039         ndr_print_uint32(ndr, "level", r->level);
9040         ndr_print_ptr(ndr, "info", r->info);
9041         ndr->depth++;
9042         if (r->info) {
9043                 ndr_print_set_switch_value(ndr, r->info, r->level);
9044                 ndr_print_drsuapi_DsAddEntryErrorInfo(ndr, "info", r->info);
9045         }
9046         ndr->depth--;
9047         ndr->depth--;
9048 }
9049
9050 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryError *r)
9051 {
9052         if (ndr_flags & NDR_SCALARS) {
9053                 int level = ndr_push_get_switch_value(ndr, r);
9054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9055                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9056                 switch (level) {
9057                         case 1: {
9058                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
9059                         break; }
9060
9061                         default:
9062                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9063                 }
9064         }
9065         if (ndr_flags & NDR_BUFFERS) {
9066                 int level = ndr_push_get_switch_value(ndr, r);
9067                 switch (level) {
9068                         case 1:
9069                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
9070                         break;
9071
9072                         default:
9073                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9074                 }
9075         }
9076         return NDR_ERR_SUCCESS;
9077 }
9078
9079 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryError *r)
9080 {
9081         int level;
9082         uint32_t _level;
9083         level = ndr_pull_get_switch_value(ndr, r);
9084         if (ndr_flags & NDR_SCALARS) {
9085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9086                 if (_level != level) {
9087                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9088                 }
9089                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9090                 switch (level) {
9091                         case 1: {
9092                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
9093                         break; }
9094
9095                         default:
9096                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9097                 }
9098         }
9099         if (ndr_flags & NDR_BUFFERS) {
9100                 switch (level) {
9101                         case 1:
9102                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
9103                         break;
9104
9105                         default:
9106                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9107                 }
9108         }
9109         return NDR_ERR_SUCCESS;
9110 }
9111
9112 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryError *r)
9113 {
9114         int level;
9115         level = ndr_print_get_switch_value(ndr, r);
9116         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryError");
9117         switch (level) {
9118                 case 1:
9119                         ndr_print_drsuapi_DsAddEntryError1(ndr, "info1", &r->info1);
9120                 break;
9121
9122                 default:
9123                         ndr_print_bad_level(ndr, name, level);
9124         }
9125 }
9126
9127 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9128 {
9129         if (ndr_flags & NDR_SCALARS) {
9130                 NDR_CHECK(ndr_push_align(ndr, 4));
9131                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
9132                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9133                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9134         }
9135         if (ndr_flags & NDR_BUFFERS) {
9136                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9137         }
9138         return NDR_ERR_SUCCESS;
9139 }
9140
9141 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier2 *r)
9142 {
9143         if (ndr_flags & NDR_SCALARS) {
9144                 NDR_CHECK(ndr_pull_align(ndr, 4));
9145                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
9146                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9147                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9148         }
9149         if (ndr_flags & NDR_BUFFERS) {
9150                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9151         }
9152         return NDR_ERR_SUCCESS;
9153 }
9154
9155 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9156 {
9157         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier2");
9158         ndr->depth++;
9159         ndr_print_GUID(ndr, "guid", &r->guid);
9160         ndr_print_dom_sid28(ndr, "sid", &r->sid);
9161         ndr->depth--;
9162 }
9163
9164 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr2 *r)
9165 {
9166         uint32_t cntr_objects_1;
9167         if (ndr_flags & NDR_SCALARS) {
9168                 NDR_CHECK(ndr_push_align(ndr, 5));
9169                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9171                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9172                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9173                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9174                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9175         }
9176         if (ndr_flags & NDR_BUFFERS) {
9177                 if (r->id) {
9178                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9179                 }
9180                 if (r->objects) {
9181                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9182                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9183                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9184                         }
9185                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9186                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9187                         }
9188                 }
9189         }
9190         return NDR_ERR_SUCCESS;
9191 }
9192
9193 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr2 *r)
9194 {
9195         uint32_t _ptr_id;
9196         TALLOC_CTX *_mem_save_id_0;
9197         uint32_t _ptr_objects;
9198         uint32_t cntr_objects_1;
9199         TALLOC_CTX *_mem_save_objects_0;
9200         TALLOC_CTX *_mem_save_objects_1;
9201         if (ndr_flags & NDR_SCALARS) {
9202                 NDR_CHECK(ndr_pull_align(ndr, 5));
9203                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9204                 if (_ptr_id) {
9205                         NDR_PULL_ALLOC(ndr, r->id);
9206                 } else {
9207                         r->id = NULL;
9208                 }
9209                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9210                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9212                 if (r->count > 10000) {
9213                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9214                 }
9215                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9216                 if (_ptr_objects) {
9217                         NDR_PULL_ALLOC(ndr, r->objects);
9218                 } else {
9219                         r->objects = NULL;
9220                 }
9221                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9222         }
9223         if (ndr_flags & NDR_BUFFERS) {
9224                 if (r->id) {
9225                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9226                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9227                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9228                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9229                 }
9230                 if (r->objects) {
9231                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9232                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9233                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9234                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9235                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9236                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9237                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9238                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9239                         }
9240                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9241                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9242                         }
9243                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9244                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9245                 }
9246                 if (r->objects) {
9247                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9248                 }
9249         }
9250         return NDR_ERR_SUCCESS;
9251 }
9252
9253 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr2 *r)
9254 {
9255         uint32_t cntr_objects_1;
9256         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr2");
9257         ndr->depth++;
9258         ndr_print_ptr(ndr, "id", r->id);
9259         ndr->depth++;
9260         if (r->id) {
9261                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9262         }
9263         ndr->depth--;
9264         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9265         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
9266         ndr_print_uint32(ndr, "count", r->count);
9267         ndr_print_ptr(ndr, "objects", r->objects);
9268         ndr->depth++;
9269         if (r->objects) {
9270                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9271                 ndr->depth++;
9272                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9273                         char *idx_1=NULL;
9274                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9275                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9276                                 free(idx_1);
9277                         }
9278                 }
9279                 ndr->depth--;
9280         }
9281         ndr->depth--;
9282         ndr->depth--;
9283 }
9284
9285 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr3 *r)
9286 {
9287         uint32_t cntr_objects_1;
9288         if (ndr_flags & NDR_SCALARS) {
9289                 NDR_CHECK(ndr_push_align(ndr, 5));
9290                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9292                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
9293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9294                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9295                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9296         }
9297         if (ndr_flags & NDR_BUFFERS) {
9298                 if (r->id) {
9299                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9300                 }
9301                 if (r->error) {
9302                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->error, r->level));
9303                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9304                 }
9305                 if (r->objects) {
9306                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9307                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9308                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9309                         }
9310                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9311                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9312                         }
9313                 }
9314         }
9315         return NDR_ERR_SUCCESS;
9316 }
9317
9318 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr3 *r)
9319 {
9320         uint32_t _ptr_id;
9321         TALLOC_CTX *_mem_save_id_0;
9322         uint32_t _ptr_error;
9323         TALLOC_CTX *_mem_save_error_0;
9324         uint32_t _ptr_objects;
9325         uint32_t cntr_objects_1;
9326         TALLOC_CTX *_mem_save_objects_0;
9327         TALLOC_CTX *_mem_save_objects_1;
9328         if (ndr_flags & NDR_SCALARS) {
9329                 NDR_CHECK(ndr_pull_align(ndr, 5));
9330                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9331                 if (_ptr_id) {
9332                         NDR_PULL_ALLOC(ndr, r->id);
9333                 } else {
9334                         r->id = NULL;
9335                 }
9336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9337                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_error));
9338                 if (_ptr_error) {
9339                         NDR_PULL_ALLOC(ndr, r->error);
9340                 } else {
9341                         r->error = NULL;
9342                 }
9343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9344                 if (r->count > 10000) {
9345                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9346                 }
9347                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9348                 if (_ptr_objects) {
9349                         NDR_PULL_ALLOC(ndr, r->objects);
9350                 } else {
9351                         r->objects = NULL;
9352                 }
9353                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9354         }
9355         if (ndr_flags & NDR_BUFFERS) {
9356                 if (r->id) {
9357                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9358                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9359                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9360                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9361                 }
9362                 if (r->error) {
9363                         _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
9364                         NDR_PULL_SET_MEM_CTX(ndr, r->error, 0);
9365                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->error, r->level));
9366                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9367                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, 0);
9368                 }
9369                 if (r->objects) {
9370                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9371                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9372                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9373                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9374                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9375                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9376                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9377                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9378                         }
9379                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9380                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9381                         }
9382                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9383                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9384                 }
9385                 if (r->objects) {
9386                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9387                 }
9388         }
9389         return NDR_ERR_SUCCESS;
9390 }
9391
9392 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr3 *r)
9393 {
9394         uint32_t cntr_objects_1;
9395         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr3");
9396         ndr->depth++;
9397         ndr_print_ptr(ndr, "id", r->id);
9398         ndr->depth++;
9399         if (r->id) {
9400                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9401         }
9402         ndr->depth--;
9403         ndr_print_uint32(ndr, "level", r->level);
9404         ndr_print_ptr(ndr, "error", r->error);
9405         ndr->depth++;
9406         if (r->error) {
9407                 ndr_print_set_switch_value(ndr, r->error, r->level);
9408                 ndr_print_drsuapi_DsAddEntryError(ndr, "error", r->error);
9409         }
9410         ndr->depth--;
9411         ndr_print_uint32(ndr, "count", r->count);
9412         ndr_print_ptr(ndr, "objects", r->objects);
9413         ndr->depth++;
9414         if (r->objects) {
9415                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9416                 ndr->depth++;
9417                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9418                         char *idx_1=NULL;
9419                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9420                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9421                                 free(idx_1);
9422                         }
9423                 }
9424                 ndr->depth--;
9425         }
9426         ndr->depth--;
9427         ndr->depth--;
9428 }
9429
9430 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryCtr *r)
9431 {
9432         if (ndr_flags & NDR_SCALARS) {
9433                 int level = ndr_push_get_switch_value(ndr, r);
9434                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
9435                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9436                 switch (level) {
9437                         case 2: {
9438                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9439                         break; }
9440
9441                         case 3: {
9442                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9443                         break; }
9444
9445                         default:
9446                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9447                 }
9448         }
9449         if (ndr_flags & NDR_BUFFERS) {
9450                 int level = ndr_push_get_switch_value(ndr, r);
9451                 switch (level) {
9452                         case 2:
9453                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9454                         break;
9455
9456                         case 3:
9457                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9458                         break;
9459
9460                         default:
9461                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9462                 }
9463         }
9464         return NDR_ERR_SUCCESS;
9465 }
9466
9467 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryCtr *r)
9468 {
9469         int level;
9470         int32_t _level;
9471         level = ndr_pull_get_switch_value(ndr, r);
9472         if (ndr_flags & NDR_SCALARS) {
9473                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
9474                 if (_level != level) {
9475                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9476                 }
9477                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9478                 switch (level) {
9479                         case 2: {
9480                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9481                         break; }
9482
9483                         case 3: {
9484                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9485                         break; }
9486
9487                         default:
9488                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9489                 }
9490         }
9491         if (ndr_flags & NDR_BUFFERS) {
9492                 switch (level) {
9493                         case 2:
9494                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9495                         break;
9496
9497                         case 3:
9498                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9499                         break;
9500
9501                         default:
9502                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9503                 }
9504         }
9505         return NDR_ERR_SUCCESS;
9506 }
9507
9508 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
9509 {
9510         int level;
9511         level = ndr_print_get_switch_value(ndr, r);
9512         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
9513         switch (level) {
9514                 case 2:
9515                         ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
9516                 break;
9517
9518                 case 3:
9519                         ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
9520                 break;
9521
9522                 default:
9523                         ndr_print_bad_level(ndr, name, level);
9524         }
9525 }
9526
9527 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9528 {
9529         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9530         return NDR_ERR_SUCCESS;
9531 }
9532
9533 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9534 {
9535         uint32_t v;
9536         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9537         *r = v;
9538         return NDR_ERR_SUCCESS;
9539 }
9540
9541 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCFlags(struct ndr_print *ndr, const char *name, uint32_t r)
9542 {
9543         ndr_print_uint32(ndr, name, r);
9544         ndr->depth++;
9545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION, r);
9546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_DAMPED", DRSUAPI_DS_EXECUTE_KCC_DAMPED, r);
9547         ndr->depth--;
9548 }
9549
9550 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsExecuteKCC1 *r)
9551 {
9552         if (ndr_flags & NDR_SCALARS) {
9553                 NDR_CHECK(ndr_push_align(ndr, 4));
9554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->taskID));
9555                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, r->flags));
9556                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9557         }
9558         if (ndr_flags & NDR_BUFFERS) {
9559         }
9560         return NDR_ERR_SUCCESS;
9561 }
9562
9563 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsExecuteKCC1 *r)
9564 {
9565         if (ndr_flags & NDR_SCALARS) {
9566                 NDR_CHECK(ndr_pull_align(ndr, 4));
9567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->taskID));
9568                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, &r->flags));
9569                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9570         }
9571         if (ndr_flags & NDR_BUFFERS) {
9572         }
9573         return NDR_ERR_SUCCESS;
9574 }
9575
9576 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsExecuteKCC1 *r)
9577 {
9578         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC1");
9579         ndr->depth++;
9580         ndr_print_uint32(ndr, "taskID", r->taskID);
9581         ndr_print_drsuapi_DsExecuteKCCFlags(ndr, "flags", r->flags);
9582         ndr->depth--;
9583 }
9584
9585 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsExecuteKCCRequest *r)
9586 {
9587         if (ndr_flags & NDR_SCALARS) {
9588                 int level = ndr_push_get_switch_value(ndr, r);
9589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9590                 NDR_CHECK(ndr_push_union_align(ndr, 4));
9591                 switch (level) {
9592                         case 1: {
9593                                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9594                         break; }
9595
9596                         default:
9597                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9598                 }
9599         }
9600         if (ndr_flags & NDR_BUFFERS) {
9601                 int level = ndr_push_get_switch_value(ndr, r);
9602                 switch (level) {
9603                         case 1:
9604                         break;
9605
9606                         default:
9607                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9608                 }
9609         }
9610         return NDR_ERR_SUCCESS;
9611 }
9612
9613 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsExecuteKCCRequest *r)
9614 {
9615         int level;
9616         uint32_t _level;
9617         level = ndr_pull_get_switch_value(ndr, r);
9618         if (ndr_flags & NDR_SCALARS) {
9619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9620                 if (_level != level) {
9621                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9622                 }
9623                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
9624                 switch (level) {
9625                         case 1: {
9626                                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9627                         break; }
9628
9629                         default:
9630                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9631                 }
9632         }
9633         if (ndr_flags & NDR_BUFFERS) {
9634                 switch (level) {
9635                         case 1:
9636                         break;
9637
9638                         default:
9639                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9640                 }
9641         }
9642         return NDR_ERR_SUCCESS;
9643 }
9644
9645 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsExecuteKCCRequest *r)
9646 {
9647         int level;
9648         level = ndr_print_get_switch_value(ndr, r);
9649         ndr_print_union(ndr, name, level, "drsuapi_DsExecuteKCCRequest");
9650         switch (level) {
9651                 case 1:
9652                         ndr_print_drsuapi_DsExecuteKCC1(ndr, "ctr1", &r->ctr1);
9653                 break;
9654
9655                 default:
9656                         ndr_print_bad_level(ndr, name, level);
9657         }
9658 }
9659
9660 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
9661 {
9662         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9663         return NDR_ERR_SUCCESS;
9664 }
9665
9666 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
9667 {
9668         uint32_t v;
9669         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9670         *r = v;
9671         return NDR_ERR_SUCCESS;
9672 }
9673
9674 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaGetInfoLevel r)
9675 {
9676         const char *val = NULL;
9677
9678         switch (r) {
9679                 case DRSUAPI_DS_REPLICA_GET_INFO: val = "DRSUAPI_DS_REPLICA_GET_INFO"; break;
9680                 case DRSUAPI_DS_REPLICA_GET_INFO2: val = "DRSUAPI_DS_REPLICA_GET_INFO2"; break;
9681         }
9682         ndr_print_enum(ndr, name, "ENUM", val, r);
9683 }
9684
9685 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
9686 {
9687         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9688         return NDR_ERR_SUCCESS;
9689 }
9690
9691 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
9692 {
9693         uint32_t v;
9694         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9695         *r = v;
9696         return NDR_ERR_SUCCESS;
9697 }
9698
9699 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaInfoType r)
9700 {
9701         const char *val = NULL;
9702
9703         switch (r) {
9704                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS"; break;
9705                 case DRSUAPI_DS_REPLICA_INFO_CURSORS: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS"; break;
9706                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA"; break;
9707                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES"; break;
9708                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES"; break;
9709                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: val = "DRSUAPI_DS_REPLICA_INFO_PENDING_OPS"; break;
9710                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA"; break;
9711                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS2"; break;
9712                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS3"; break;
9713                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2"; break;
9714                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2"; break;
9715                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02"; break;
9716                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: val = "DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04"; break;
9717                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS05"; break;
9718                 case DRSUAPI_DS_REPLICA_INFO_06: val = "DRSUAPI_DS_REPLICA_INFO_06"; break;
9719         }
9720         ndr_print_enum(ndr, name, "ENUM", val, r);
9721 }
9722
9723 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9724 {
9725         if (ndr_flags & NDR_SCALARS) {
9726                 NDR_CHECK(ndr_push_align(ndr, 5));
9727                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9728                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9729                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9730                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9731         }
9732         if (ndr_flags & NDR_BUFFERS) {
9733                 if (r->object_dn) {
9734                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9735                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9736                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9737                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9738                 }
9739         }
9740         return NDR_ERR_SUCCESS;
9741 }
9742
9743 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
9744 {
9745         uint32_t _ptr_object_dn;
9746         TALLOC_CTX *_mem_save_object_dn_0;
9747         if (ndr_flags & NDR_SCALARS) {
9748                 NDR_CHECK(ndr_pull_align(ndr, 5));
9749                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9751                 if (_ptr_object_dn) {
9752                         NDR_PULL_ALLOC(ndr, r->object_dn);
9753                 } else {
9754                         r->object_dn = NULL;
9755                 }
9756                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9757                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9758         }
9759         if (ndr_flags & NDR_BUFFERS) {
9760                 if (r->object_dn) {
9761                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9762                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9763                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9764                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9765                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9766                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->object_dn), ndr_get_array_length(ndr, &r->object_dn));
9767                         }
9768                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9769                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9770                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9771                 }
9772         }
9773         return NDR_ERR_SUCCESS;
9774 }
9775
9776 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9777 {
9778         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest1");
9779         ndr->depth++;
9780         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9781         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9782         ndr->depth++;
9783         if (r->object_dn) {
9784                 ndr_print_string(ndr, "object_dn", r->object_dn);
9785         }
9786         ndr->depth--;
9787         ndr_print_GUID(ndr, "guid1", &r->guid1);
9788         ndr->depth--;
9789 }
9790
9791 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9792 {
9793         if (ndr_flags & NDR_SCALARS) {
9794                 NDR_CHECK(ndr_push_align(ndr, 5));
9795                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9796                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9797                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9799                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string1));
9800                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string2));
9801                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
9802                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9803         }
9804         if (ndr_flags & NDR_BUFFERS) {
9805                 if (r->object_dn) {
9806                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9807                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9808                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9809                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9810                 }
9811                 if (r->string1) {
9812                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9813                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9814                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9815                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string1, ndr_charset_length(r->string1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9816                 }
9817                 if (r->string2) {
9818                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9819                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9820                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9821                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string2, ndr_charset_length(r->string2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9822                 }
9823         }
9824         return NDR_ERR_SUCCESS;
9825 }
9826
9827 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
9828 {
9829         uint32_t _ptr_object_dn;
9830         TALLOC_CTX *_mem_save_object_dn_0;
9831         uint32_t _ptr_string1;
9832         TALLOC_CTX *_mem_save_string1_0;
9833         uint32_t _ptr_string2;
9834         TALLOC_CTX *_mem_save_string2_0;
9835         if (ndr_flags & NDR_SCALARS) {
9836                 NDR_CHECK(ndr_pull_align(ndr, 5));
9837                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9838                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9839                 if (_ptr_object_dn) {
9840                         NDR_PULL_ALLOC(ndr, r->object_dn);
9841                 } else {
9842                         r->object_dn = NULL;
9843                 }
9844                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9846                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string1));
9847                 if (_ptr_string1) {
9848                         NDR_PULL_ALLOC(ndr, r->string1);
9849                 } else {
9850                         r->string1 = NULL;
9851                 }
9852                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string2));
9853                 if (_ptr_string2) {
9854                         NDR_PULL_ALLOC(ndr, r->string2);
9855                 } else {
9856                         r->string2 = NULL;
9857                 }
9858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
9859                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9860         }
9861         if (ndr_flags & NDR_BUFFERS) {
9862                 if (r->object_dn) {
9863                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9864                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9865                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9866                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9867                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9868                                 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));
9869                         }
9870                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9871                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9872                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9873                 }
9874                 if (r->string1) {
9875                         _mem_save_string1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9876                         NDR_PULL_SET_MEM_CTX(ndr, r->string1, 0);
9877                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string1));
9878                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string1));
9879                         if (ndr_get_array_length(ndr, &r->string1) > ndr_get_array_size(ndr, &r->string1)) {
9880                                 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));
9881                         }
9882                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t)));
9883                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string1, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t), CH_UTF16));
9884                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string1_0, 0);
9885                 }
9886                 if (r->string2) {
9887                         _mem_save_string2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9888                         NDR_PULL_SET_MEM_CTX(ndr, r->string2, 0);
9889                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string2));
9890                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string2));
9891                         if (ndr_get_array_length(ndr, &r->string2) > ndr_get_array_size(ndr, &r->string2)) {
9892                                 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));
9893                         }
9894                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t)));
9895                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string2, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t), CH_UTF16));
9896                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string2_0, 0);
9897                 }
9898         }
9899         return NDR_ERR_SUCCESS;
9900 }
9901
9902 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9903 {
9904         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest2");
9905         ndr->depth++;
9906         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9907         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9908         ndr->depth++;
9909         if (r->object_dn) {
9910                 ndr_print_string(ndr, "object_dn", r->object_dn);
9911         }
9912         ndr->depth--;
9913         ndr_print_GUID(ndr, "guid1", &r->guid1);
9914         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9915         ndr_print_ptr(ndr, "string1", r->string1);
9916         ndr->depth++;
9917         if (r->string1) {
9918                 ndr_print_string(ndr, "string1", r->string1);
9919         }
9920         ndr->depth--;
9921         ndr_print_ptr(ndr, "string2", r->string2);
9922         ndr->depth++;
9923         if (r->string2) {
9924                 ndr_print_string(ndr, "string2", r->string2);
9925         }
9926         ndr->depth--;
9927         ndr_print_uint32(ndr, "unknown2", r->unknown2);
9928         ndr->depth--;
9929 }
9930
9931 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaGetInfoRequest *r)
9932 {
9933         if (ndr_flags & NDR_SCALARS) {
9934                 int level = ndr_push_get_switch_value(ndr, r);
9935                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
9936                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9937                 switch (level) {
9938                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9939                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9940                         break; }
9941
9942                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9943                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9944                         break; }
9945
9946                         default:
9947                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9948                 }
9949         }
9950         if (ndr_flags & NDR_BUFFERS) {
9951                 int level = ndr_push_get_switch_value(ndr, r);
9952                 switch (level) {
9953                         case DRSUAPI_DS_REPLICA_GET_INFO:
9954                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9955                         break;
9956
9957                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9958                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9959                         break;
9960
9961                         default:
9962                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9963                 }
9964         }
9965         return NDR_ERR_SUCCESS;
9966 }
9967
9968 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaGetInfoRequest *r)
9969 {
9970         int level;
9971         uint32_t _level;
9972         level = ndr_pull_get_switch_value(ndr, r);
9973         if (ndr_flags & NDR_SCALARS) {
9974                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9975                 if (_level != level) {
9976                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9977                 }
9978                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9979                 switch (level) {
9980                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9981                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9982                         break; }
9983
9984                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9985                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9986                         break; }
9987
9988                         default:
9989                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9990                 }
9991         }
9992         if (ndr_flags & NDR_BUFFERS) {
9993                 switch (level) {
9994                         case DRSUAPI_DS_REPLICA_GET_INFO:
9995                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9996                         break;
9997
9998                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9999                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
10000                         break;
10001
10002                         default:
10003                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10004                 }
10005         }
10006         return NDR_ERR_SUCCESS;
10007 }
10008
10009 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaGetInfoRequest *r)
10010 {
10011         int level;
10012         level = ndr_print_get_switch_value(ndr, r);
10013         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaGetInfoRequest");
10014         switch (level) {
10015                 case DRSUAPI_DS_REPLICA_GET_INFO:
10016                         ndr_print_drsuapi_DsReplicaGetInfoRequest1(ndr, "req1", &r->req1);
10017                 break;
10018
10019                 case DRSUAPI_DS_REPLICA_GET_INFO2:
10020                         ndr_print_drsuapi_DsReplicaGetInfoRequest2(ndr, "req2", &r->req2);
10021                 break;
10022
10023                 default:
10024                         ndr_print_bad_level(ndr, name, level);
10025         }
10026 }
10027
10028 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbour *r)
10029 {
10030         if (ndr_flags & NDR_SCALARS) {
10031                 NDR_CHECK(ndr_push_align(ndr, 8));
10032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context_dn));
10033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
10034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
10035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_obj_dn));
10036                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
10037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10038                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
10039                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
10040                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
10041                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
10042                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
10043                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
10044                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_success));
10045                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
10046                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
10047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
10048                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10049         }
10050         if (ndr_flags & NDR_BUFFERS) {
10051                 if (r->naming_context_dn) {
10052                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
10053                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10054                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
10055                         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));
10056                 }
10057                 if (r->source_dsa_obj_dn) {
10058                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
10059                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10060                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
10061                         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));
10062                 }
10063                 if (r->source_dsa_address) {
10064                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
10065                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10066                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
10067                         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));
10068                 }
10069                 if (r->transport_obj_dn) {
10070                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
10071                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10072                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
10073                         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));
10074                 }
10075         }
10076         return NDR_ERR_SUCCESS;
10077 }
10078
10079 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
10080 {
10081         uint32_t _ptr_naming_context_dn;
10082         TALLOC_CTX *_mem_save_naming_context_dn_0;
10083         uint32_t _ptr_source_dsa_obj_dn;
10084         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
10085         uint32_t _ptr_source_dsa_address;
10086         TALLOC_CTX *_mem_save_source_dsa_address_0;
10087         uint32_t _ptr_transport_obj_dn;
10088         TALLOC_CTX *_mem_save_transport_obj_dn_0;
10089         if (ndr_flags & NDR_SCALARS) {
10090                 NDR_CHECK(ndr_pull_align(ndr, 8));
10091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context_dn));
10092                 if (_ptr_naming_context_dn) {
10093                         NDR_PULL_ALLOC(ndr, r->naming_context_dn);
10094                 } else {
10095                         r->naming_context_dn = NULL;
10096                 }
10097                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
10098                 if (_ptr_source_dsa_obj_dn) {
10099                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
10100                 } else {
10101                         r->source_dsa_obj_dn = NULL;
10102                 }
10103                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
10104                 if (_ptr_source_dsa_address) {
10105                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
10106                 } else {
10107                         r->source_dsa_address = NULL;
10108                 }
10109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_obj_dn));
10110                 if (_ptr_transport_obj_dn) {
10111                         NDR_PULL_ALLOC(ndr, r->transport_obj_dn);
10112                 } else {
10113                         r->transport_obj_dn = NULL;
10114                 }
10115                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
10116                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10117                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
10118                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
10119                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
10120                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
10121                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
10122                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
10123                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_success));
10124                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
10125                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
10126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
10127                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10128         }
10129         if (ndr_flags & NDR_BUFFERS) {
10130                 if (r->naming_context_dn) {
10131                         _mem_save_naming_context_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10132                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
10133                         NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
10134                         NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
10135                         if (ndr_get_array_length(ndr, &r->naming_context_dn) > ndr_get_array_size(ndr, &r->naming_context_dn)) {
10136                                 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));
10137                         }
10138                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t)));
10139                         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));
10140                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
10141                 }
10142                 if (r->source_dsa_obj_dn) {
10143                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10144                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
10145                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
10146                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
10147                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
10148                                 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));
10149                         }
10150                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
10151                         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));
10152                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
10153                 }
10154                 if (r->source_dsa_address) {
10155                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10156                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
10157                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
10158                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
10159                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
10160                                 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));
10161                         }
10162                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
10163                         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));
10164                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
10165                 }
10166                 if (r->transport_obj_dn) {
10167                         _mem_save_transport_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10168                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
10169                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
10170                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
10171                         if (ndr_get_array_length(ndr, &r->transport_obj_dn) > ndr_get_array_size(ndr, &r->transport_obj_dn)) {
10172                                 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));
10173                         }
10174                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t)));
10175                         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));
10176                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
10177                 }
10178         }
10179         return NDR_ERR_SUCCESS;
10180 }
10181
10182 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbour(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbour *r)
10183 {
10184         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbour");
10185         ndr->depth++;
10186         ndr_print_ptr(ndr, "naming_context_dn", r->naming_context_dn);
10187         ndr->depth++;
10188         if (r->naming_context_dn) {
10189                 ndr_print_string(ndr, "naming_context_dn", r->naming_context_dn);
10190         }
10191         ndr->depth--;
10192         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10193         ndr->depth++;
10194         if (r->source_dsa_obj_dn) {
10195                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10196         }
10197         ndr->depth--;
10198         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
10199         ndr->depth++;
10200         if (r->source_dsa_address) {
10201                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
10202         }
10203         ndr->depth--;
10204         ndr_print_ptr(ndr, "transport_obj_dn", r->transport_obj_dn);
10205         ndr->depth++;
10206         if (r->transport_obj_dn) {
10207                 ndr_print_string(ndr, "transport_obj_dn", r->transport_obj_dn);
10208         }
10209         ndr->depth--;
10210         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
10211         ndr_print_uint32(ndr, "reserved", r->reserved);
10212         ndr_print_GUID(ndr, "naming_context_obj_guid", &r->naming_context_obj_guid);
10213         ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
10214         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
10215         ndr_print_GUID(ndr, "transport_obj_guid", &r->transport_obj_guid);
10216         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
10217         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
10218         ndr_print_NTTIME(ndr, "last_success", r->last_success);
10219         ndr_print_NTTIME(ndr, "last_attempt", r->last_attempt);
10220         ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
10221         ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
10222         ndr->depth--;
10223 }
10224
10225 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbourCtr *r)
10226 {
10227         uint32_t cntr_array_0;
10228         if (ndr_flags & NDR_SCALARS) {
10229                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10230                 NDR_CHECK(ndr_push_align(ndr, 8));
10231                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10233                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10234                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10235                 }
10236                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10237         }
10238         if (ndr_flags & NDR_BUFFERS) {
10239                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10240                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10241                 }
10242         }
10243         return NDR_ERR_SUCCESS;
10244 }
10245
10246 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
10247 {
10248         uint32_t cntr_array_0;
10249         TALLOC_CTX *_mem_save_array_0;
10250         if (ndr_flags & NDR_SCALARS) {
10251                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10252                 NDR_CHECK(ndr_pull_align(ndr, 8));
10253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10255                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10256                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10257                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10258                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10259                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10260                 }
10261                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10262                 if (r->array) {
10263                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10264                 }
10265                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10266         }
10267         if (ndr_flags & NDR_BUFFERS) {
10268                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10269                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10270                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10271                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10272                 }
10273                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10274         }
10275         return NDR_ERR_SUCCESS;
10276 }
10277
10278 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbourCtr *r)
10279 {
10280         uint32_t cntr_array_0;
10281         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbourCtr");
10282         ndr->depth++;
10283         ndr_print_uint32(ndr, "count", r->count);
10284         ndr_print_uint32(ndr, "reserved", r->reserved);
10285         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10286         ndr->depth++;
10287         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10288                 char *idx_0=NULL;
10289                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10290                         ndr_print_drsuapi_DsReplicaNeighbour(ndr, "array", &r->array[cntr_array_0]);
10291                         free(idx_0);
10292                 }
10293         }
10294         ndr->depth--;
10295         ndr->depth--;
10296 }
10297
10298 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtr *r)
10299 {
10300         uint32_t cntr_array_0;
10301         if (ndr_flags & NDR_SCALARS) {
10302                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10303                 NDR_CHECK(ndr_push_align(ndr, 8));
10304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10306                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10307                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10308                 }
10309                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10310         }
10311         if (ndr_flags & NDR_BUFFERS) {
10312         }
10313         return NDR_ERR_SUCCESS;
10314 }
10315
10316 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
10317 {
10318         uint32_t cntr_array_0;
10319         TALLOC_CTX *_mem_save_array_0;
10320         if (ndr_flags & NDR_SCALARS) {
10321                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10322                 NDR_CHECK(ndr_pull_align(ndr, 8));
10323                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10325                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10326                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10327                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10328                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10329                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10330                 }
10331                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10332                 if (r->array) {
10333                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10334                 }
10335                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10336         }
10337         if (ndr_flags & NDR_BUFFERS) {
10338         }
10339         return NDR_ERR_SUCCESS;
10340 }
10341
10342 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtr *r)
10343 {
10344         uint32_t cntr_array_0;
10345         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtr");
10346         ndr->depth++;
10347         ndr_print_uint32(ndr, "count", r->count);
10348         ndr_print_uint32(ndr, "reserved", r->reserved);
10349         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10350         ndr->depth++;
10351         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10352                 char *idx_0=NULL;
10353                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10354                         ndr_print_drsuapi_DsReplicaCursor(ndr, "array", &r->array[cntr_array_0]);
10355                         free(idx_0);
10356                 }
10357         }
10358         ndr->depth--;
10359         ndr->depth--;
10360 }
10361
10362 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData *r)
10363 {
10364         if (ndr_flags & NDR_SCALARS) {
10365                 NDR_CHECK(ndr_push_align(ndr, 8));
10366                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10368                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10369                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10370                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10371                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10372                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10373         }
10374         if (ndr_flags & NDR_BUFFERS) {
10375                 if (r->attribute_name) {
10376                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10377                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10378                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10379                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10380                 }
10381         }
10382         return NDR_ERR_SUCCESS;
10383 }
10384
10385 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
10386 {
10387         uint32_t _ptr_attribute_name;
10388         TALLOC_CTX *_mem_save_attribute_name_0;
10389         if (ndr_flags & NDR_SCALARS) {
10390                 NDR_CHECK(ndr_pull_align(ndr, 8));
10391                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10392                 if (_ptr_attribute_name) {
10393                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10394                 } else {
10395                         r->attribute_name = NULL;
10396                 }
10397                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10398                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10399                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10400                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10401                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10402                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10403         }
10404         if (ndr_flags & NDR_BUFFERS) {
10405                 if (r->attribute_name) {
10406                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10407                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10408                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10409                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10410                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10411                                 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));
10412                         }
10413                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10414                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10415                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10416                 }
10417         }
10418         return NDR_ERR_SUCCESS;
10419 }
10420
10421 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData *r)
10422 {
10423         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData");
10424         ndr->depth++;
10425         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10426         ndr->depth++;
10427         if (r->attribute_name) {
10428                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10429         }
10430         ndr->depth--;
10431         ndr_print_uint32(ndr, "version", r->version);
10432         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10433         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10434         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10435         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10436         ndr->depth--;
10437 }
10438
10439 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10440 {
10441         uint32_t cntr_array_0;
10442         if (ndr_flags & NDR_SCALARS) {
10443                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10444                 NDR_CHECK(ndr_push_align(ndr, 8));
10445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10447                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10448                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10449                 }
10450                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10451         }
10452         if (ndr_flags & NDR_BUFFERS) {
10453                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10454                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10455                 }
10456         }
10457         return NDR_ERR_SUCCESS;
10458 }
10459
10460 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
10461 {
10462         uint32_t cntr_array_0;
10463         TALLOC_CTX *_mem_save_array_0;
10464         if (ndr_flags & NDR_SCALARS) {
10465                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10466                 NDR_CHECK(ndr_pull_align(ndr, 8));
10467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10468                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10469                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10470                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10471                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10472                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10473                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10474                 }
10475                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10476                 if (r->array) {
10477                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10478                 }
10479                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10480         }
10481         if (ndr_flags & NDR_BUFFERS) {
10482                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10483                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10484                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10485                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10486                 }
10487                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10488         }
10489         return NDR_ERR_SUCCESS;
10490 }
10491
10492 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10493 {
10494         uint32_t cntr_array_0;
10495         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaDataCtr");
10496         ndr->depth++;
10497         ndr_print_uint32(ndr, "count", r->count);
10498         ndr_print_uint32(ndr, "reserved", r->reserved);
10499         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10500         ndr->depth++;
10501         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10502                 char *idx_0=NULL;
10503                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10504                         ndr_print_drsuapi_DsReplicaObjMetaData(ndr, "array", &r->array[cntr_array_0]);
10505                         free(idx_0);
10506                 }
10507         }
10508         ndr->depth--;
10509         ndr->depth--;
10510 }
10511
10512 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
10513 {
10514         if (ndr_flags & NDR_SCALARS) {
10515                 NDR_CHECK(ndr_push_align(ndr, 5));
10516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
10517                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10518                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
10519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
10520                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
10521                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10522         }
10523         if (ndr_flags & NDR_BUFFERS) {
10524                 if (r->dsa_obj_dn) {
10525                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10526                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10527                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10528                         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));
10529                 }
10530         }
10531         return NDR_ERR_SUCCESS;
10532 }
10533
10534 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
10535 {
10536         uint32_t _ptr_dsa_obj_dn;
10537         TALLOC_CTX *_mem_save_dsa_obj_dn_0;
10538         if (ndr_flags & NDR_SCALARS) {
10539                 NDR_CHECK(ndr_pull_align(ndr, 5));
10540                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
10541                 if (_ptr_dsa_obj_dn) {
10542                         NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
10543                 } else {
10544                         r->dsa_obj_dn = NULL;
10545                 }
10546                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10547                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
10548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
10549                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
10550                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10551         }
10552         if (ndr_flags & NDR_BUFFERS) {
10553                 if (r->dsa_obj_dn) {
10554                         _mem_save_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10555                         NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
10556                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
10557                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
10558                         if (ndr_get_array_length(ndr, &r->dsa_obj_dn) > ndr_get_array_size(ndr, &r->dsa_obj_dn)) {
10559                                 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));
10560                         }
10561                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t)));
10562                         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));
10563                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
10564                 }
10565         }
10566         return NDR_ERR_SUCCESS;
10567 }
10568
10569 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailure(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailure *r)
10570 {
10571         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailure");
10572         ndr->depth++;
10573         ndr_print_ptr(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10574         ndr->depth++;
10575         if (r->dsa_obj_dn) {
10576                 ndr_print_string(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10577         }
10578         ndr->depth--;
10579         ndr_print_GUID(ndr, "dsa_obj_guid", &r->dsa_obj_guid);
10580         ndr_print_NTTIME(ndr, "first_failure", r->first_failure);
10581         ndr_print_uint32(ndr, "num_failures", r->num_failures);
10582         ndr_print_WERROR(ndr, "last_result", r->last_result);
10583         ndr->depth--;
10584 }
10585
10586 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10587 {
10588         uint32_t cntr_array_0;
10589         if (ndr_flags & NDR_SCALARS) {
10590                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10591                 NDR_CHECK(ndr_push_align(ndr, 5));
10592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10594                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10595                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10596                 }
10597                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10598         }
10599         if (ndr_flags & NDR_BUFFERS) {
10600                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10601                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10602                 }
10603         }
10604         return NDR_ERR_SUCCESS;
10605 }
10606
10607 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10608 {
10609         uint32_t cntr_array_0;
10610         TALLOC_CTX *_mem_save_array_0;
10611         if (ndr_flags & NDR_SCALARS) {
10612                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10613                 NDR_CHECK(ndr_pull_align(ndr, 5));
10614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10616                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10617                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10618                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10619                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10620                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10621                 }
10622                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10623                 if (r->array) {
10624                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10625                 }
10626                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10627         }
10628         if (ndr_flags & NDR_BUFFERS) {
10629                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10630                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10631                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10632                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10633                 }
10634                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10635         }
10636         return NDR_ERR_SUCCESS;
10637 }
10638
10639 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10640 {
10641         uint32_t cntr_array_0;
10642         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailuresCtr");
10643         ndr->depth++;
10644         ndr_print_uint32(ndr, "count", r->count);
10645         ndr_print_uint32(ndr, "reserved", r->reserved);
10646         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10647         ndr->depth++;
10648         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10649                 char *idx_0=NULL;
10650                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10651                         ndr_print_drsuapi_DsReplicaKccDsaFailure(ndr, "array", &r->array[cntr_array_0]);
10652                         free(idx_0);
10653                 }
10654         }
10655         ndr->depth--;
10656         ndr->depth--;
10657 }
10658
10659 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
10660 {
10661         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
10662         return NDR_ERR_SUCCESS;
10663 }
10664
10665 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
10666 {
10667         uint16_t v;
10668         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
10669         *r = v;
10670         return NDR_ERR_SUCCESS;
10671 }
10672
10673 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaOpType r)
10674 {
10675         const char *val = NULL;
10676
10677         switch (r) {
10678                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: val = "DRSUAPI_DS_REPLICA_OP_TYPE_SYNC"; break;
10679                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: val = "DRSUAPI_DS_REPLICA_OP_TYPE_ADD"; break;
10680                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: val = "DRSUAPI_DS_REPLICA_OP_TYPE_DELETE"; break;
10681                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: val = "DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY"; break;
10682                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: val = "DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS"; break;
10683         }
10684         ndr_print_enum(ndr, name, "ENUM", val, r);
10685 }
10686
10687 static enum ndr_err_code ndr_push_drsuapi_DsRplicaOpOptions(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRplicaOpOptions *r)
10688 {
10689         if (ndr_flags & NDR_SCALARS) {
10690                 int level = ndr_push_get_switch_value(ndr, r);
10691                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, level));
10692                 NDR_CHECK(ndr_push_union_align(ndr, 4));
10693                 switch (level) {
10694                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
10695                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->sync));
10696                         break; }
10697
10698                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
10699                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->add));
10700                         break; }
10701
10702                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
10703                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->op_delete));
10704                         break; }
10705
10706                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
10707                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->modify));
10708                         break; }
10709
10710                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
10711                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->update_refs));
10712                         break; }
10713
10714                         default: {
10715                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
10716                         break; }
10717
10718                 }
10719         }
10720         if (ndr_flags & NDR_BUFFERS) {
10721                 int level = ndr_push_get_switch_value(ndr, r);
10722                 switch (level) {
10723                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10724                         break;
10725
10726                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10727                         break;
10728
10729                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10730                         break;
10731
10732                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10733                         break;
10734
10735                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10736                         break;
10737
10738                         default:
10739                         break;
10740
10741                 }
10742         }
10743         return NDR_ERR_SUCCESS;
10744 }
10745
10746 static enum ndr_err_code ndr_pull_drsuapi_DsRplicaOpOptions(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRplicaOpOptions *r)
10747 {
10748         int level;
10749         uint16_t _level;
10750         level = ndr_pull_get_switch_value(ndr, r);
10751         if (ndr_flags & NDR_SCALARS) {
10752                 NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
10753                 if (_level != level) {
10754                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10755                 }
10756                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
10757                 switch (level) {
10758                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
10759                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->sync));
10760                         break; }
10761
10762                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
10763                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->add));
10764                         break; }
10765
10766                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
10767                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->op_delete));
10768                         break; }
10769
10770                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
10771                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->modify));
10772                         break; }
10773
10774                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
10775                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->update_refs));
10776                         break; }
10777
10778                         default: {
10779                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
10780                         break; }
10781
10782                 }
10783         }
10784         if (ndr_flags & NDR_BUFFERS) {
10785                 switch (level) {
10786                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10787                         break;
10788
10789                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10790                         break;
10791
10792                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10793                         break;
10794
10795                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10796                         break;
10797
10798                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10799                         break;
10800
10801                         default:
10802                         break;
10803
10804                 }
10805         }
10806         return NDR_ERR_SUCCESS;
10807 }
10808
10809 _PUBLIC_ void ndr_print_drsuapi_DsRplicaOpOptions(struct ndr_print *ndr, const char *name, const union drsuapi_DsRplicaOpOptions *r)
10810 {
10811         int level;
10812         level = ndr_print_get_switch_value(ndr, r);
10813         ndr_print_union(ndr, name, level, "drsuapi_DsRplicaOpOptions");
10814         switch (level) {
10815                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10816                         ndr_print_drsuapi_DsReplicaSyncOptions(ndr, "sync", r->sync);
10817                 break;
10818
10819                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10820                         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "add", r->add);
10821                 break;
10822
10823                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10824                         ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "op_delete", r->op_delete);
10825                 break;
10826
10827                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10828                         ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "modify", r->modify);
10829                 break;
10830
10831                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10832                         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "update_refs", r->update_refs);
10833                 break;
10834
10835                 default:
10836                         ndr_print_uint32(ndr, "unknown", r->unknown);
10837                 break;
10838
10839         }
10840 }
10841
10842 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
10843 {
10844         if (ndr_flags & NDR_SCALARS) {
10845                 NDR_CHECK(ndr_push_align(ndr, 5));
10846                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
10847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
10848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
10849                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
10850                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->options, r->operation_type));
10851                 NDR_CHECK(ndr_push_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
10852                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
10853                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
10854                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
10855                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10856                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10857                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10858         }
10859         if (ndr_flags & NDR_BUFFERS) {
10860                 if (r->nc_dn) {
10861                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10862                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10863                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10864                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10865                 }
10866                 if (r->remote_dsa_obj_dn) {
10867                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10868                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10869                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10870                         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));
10871                 }
10872                 if (r->remote_dsa_address) {
10873                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10874                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10875                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10876                         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));
10877                 }
10878         }
10879         return NDR_ERR_SUCCESS;
10880 }
10881
10882 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
10883 {
10884         uint32_t _ptr_nc_dn;
10885         TALLOC_CTX *_mem_save_nc_dn_0;
10886         uint32_t _ptr_remote_dsa_obj_dn;
10887         TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
10888         uint32_t _ptr_remote_dsa_address;
10889         TALLOC_CTX *_mem_save_remote_dsa_address_0;
10890         if (ndr_flags & NDR_SCALARS) {
10891                 NDR_CHECK(ndr_pull_align(ndr, 5));
10892                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
10893                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
10894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
10895                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
10896                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->options, r->operation_type));
10897                 NDR_CHECK(ndr_pull_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
10898                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
10899                 if (_ptr_nc_dn) {
10900                         NDR_PULL_ALLOC(ndr, r->nc_dn);
10901                 } else {
10902                         r->nc_dn = NULL;
10903                 }
10904                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_obj_dn));
10905                 if (_ptr_remote_dsa_obj_dn) {
10906                         NDR_PULL_ALLOC(ndr, r->remote_dsa_obj_dn);
10907                 } else {
10908                         r->remote_dsa_obj_dn = NULL;
10909                 }
10910                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_address));
10911                 if (_ptr_remote_dsa_address) {
10912                         NDR_PULL_ALLOC(ndr, r->remote_dsa_address);
10913                 } else {
10914                         r->remote_dsa_address = NULL;
10915                 }
10916                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10917                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10918                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10919         }
10920         if (ndr_flags & NDR_BUFFERS) {
10921                 if (r->nc_dn) {
10922                         _mem_save_nc_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10923                         NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
10924                         NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
10925                         NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
10926                         if (ndr_get_array_length(ndr, &r->nc_dn) > ndr_get_array_size(ndr, &r->nc_dn)) {
10927                                 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));
10928                         }
10929                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t)));
10930                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t), CH_UTF16));
10931                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
10932                 }
10933                 if (r->remote_dsa_obj_dn) {
10934                         _mem_save_remote_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10935                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
10936                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
10937                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
10938                         if (ndr_get_array_length(ndr, &r->remote_dsa_obj_dn) > ndr_get_array_size(ndr, &r->remote_dsa_obj_dn)) {
10939                                 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));
10940                         }
10941                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t)));
10942                         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));
10943                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
10944                 }
10945                 if (r->remote_dsa_address) {
10946                         _mem_save_remote_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10947                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
10948                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
10949                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
10950                         if (ndr_get_array_length(ndr, &r->remote_dsa_address) > ndr_get_array_size(ndr, &r->remote_dsa_address)) {
10951                                 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));
10952                         }
10953                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t)));
10954                         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));
10955                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
10956                 }
10957         }
10958         return NDR_ERR_SUCCESS;
10959 }
10960
10961 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOp *r)
10962 {
10963         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOp");
10964         ndr->depth++;
10965         ndr_print_NTTIME(ndr, "operation_start", r->operation_start);
10966         ndr_print_uint32(ndr, "serial_num", r->serial_num);
10967         ndr_print_uint32(ndr, "priority", r->priority);
10968         ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
10969         ndr_print_set_switch_value(ndr, &r->options, r->operation_type);
10970         ndr_print_drsuapi_DsRplicaOpOptions(ndr, "options", &r->options);
10971         ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
10972         ndr->depth++;
10973         if (r->nc_dn) {
10974                 ndr_print_string(ndr, "nc_dn", r->nc_dn);
10975         }
10976         ndr->depth--;
10977         ndr_print_ptr(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10978         ndr->depth++;
10979         if (r->remote_dsa_obj_dn) {
10980                 ndr_print_string(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10981         }
10982         ndr->depth--;
10983         ndr_print_ptr(ndr, "remote_dsa_address", r->remote_dsa_address);
10984         ndr->depth++;
10985         if (r->remote_dsa_address) {
10986                 ndr_print_string(ndr, "remote_dsa_address", r->remote_dsa_address);
10987         }
10988         ndr->depth--;
10989         ndr_print_GUID(ndr, "nc_obj_guid", &r->nc_obj_guid);
10990         ndr_print_GUID(ndr, "remote_dsa_obj_guid", &r->remote_dsa_obj_guid);
10991         ndr->depth--;
10992 }
10993
10994 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOpCtr *r)
10995 {
10996         uint32_t cntr_array_0;
10997         if (ndr_flags & NDR_SCALARS) {
10998                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10999                 NDR_CHECK(ndr_push_align(ndr, 5));
11000                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
11001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11002                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11003                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11004                 }
11005                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11006         }
11007         if (ndr_flags & NDR_BUFFERS) {
11008                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11009                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11010                 }
11011         }
11012         return NDR_ERR_SUCCESS;
11013 }
11014
11015 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
11016 {
11017         uint32_t cntr_array_0;
11018         TALLOC_CTX *_mem_save_array_0;
11019         if (ndr_flags & NDR_SCALARS) {
11020                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11021                 NDR_CHECK(ndr_pull_align(ndr, 5));
11022                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
11023                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11024                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11025                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11026                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11027                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11028                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11029                 }
11030                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11031                 if (r->array) {
11032                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11033                 }
11034                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11035         }
11036         if (ndr_flags & NDR_BUFFERS) {
11037                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11038                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11039                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11040                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11041                 }
11042                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11043         }
11044         return NDR_ERR_SUCCESS;
11045 }
11046
11047 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOpCtr *r)
11048 {
11049         uint32_t cntr_array_0;
11050         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOpCtr");
11051         ndr->depth++;
11052         ndr_print_NTTIME(ndr, "time", r->time);
11053         ndr_print_uint32(ndr, "count", r->count);
11054         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11055         ndr->depth++;
11056         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11057                 char *idx_0=NULL;
11058                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11059                         ndr_print_drsuapi_DsReplicaOp(ndr, "array", &r->array[cntr_array_0]);
11060                         free(idx_0);
11061                 }
11062         }
11063         ndr->depth--;
11064         ndr->depth--;
11065 }
11066
11067 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData *r)
11068 {
11069         if (ndr_flags & NDR_SCALARS) {
11070                 NDR_CHECK(ndr_push_align(ndr, 8));
11071                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11072                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11074                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11075                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11076                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11078                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11079                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11080                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11081                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11082                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11083         }
11084         if (ndr_flags & NDR_BUFFERS) {
11085                 if (r->attribute_name) {
11086                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11087                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11088                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11089                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11090                 }
11091                 if (r->object_dn) {
11092                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11093                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11094                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11095                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11096                 }
11097                 if (r->binary) {
11098                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11099                 }
11100         }
11101         return NDR_ERR_SUCCESS;
11102 }
11103
11104 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
11105 {
11106         uint32_t _ptr_attribute_name;
11107         TALLOC_CTX *_mem_save_attribute_name_0;
11108         uint32_t _ptr_object_dn;
11109         TALLOC_CTX *_mem_save_object_dn_0;
11110         uint32_t _ptr_binary;
11111         TALLOC_CTX *_mem_save_binary_0;
11112         if (ndr_flags & NDR_SCALARS) {
11113                 NDR_CHECK(ndr_pull_align(ndr, 8));
11114                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11115                 if (_ptr_attribute_name) {
11116                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11117                 } else {
11118                         r->attribute_name = NULL;
11119                 }
11120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11121                 if (_ptr_object_dn) {
11122                         NDR_PULL_ALLOC(ndr, r->object_dn);
11123                 } else {
11124                         r->object_dn = NULL;
11125                 }
11126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11128                 if (_ptr_binary) {
11129                         NDR_PULL_ALLOC(ndr, r->binary);
11130                 } else {
11131                         r->binary = NULL;
11132                 }
11133                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11134                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11136                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11137                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11138                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11139                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11140                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11141         }
11142         if (ndr_flags & NDR_BUFFERS) {
11143                 if (r->attribute_name) {
11144                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11145                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11146                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11147                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11148                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11149                                 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));
11150                         }
11151                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11152                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11153                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11154                 }
11155                 if (r->object_dn) {
11156                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11157                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11158                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11159                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11160                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11161                                 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));
11162                         }
11163                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11164                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11165                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11166                 }
11167                 if (r->binary) {
11168                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11169                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11170                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11172                 }
11173         }
11174         return NDR_ERR_SUCCESS;
11175 }
11176
11177 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData *r)
11178 {
11179         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData");
11180         ndr->depth++;
11181         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11182         ndr->depth++;
11183         if (r->attribute_name) {
11184                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11185         }
11186         ndr->depth--;
11187         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11188         ndr->depth++;
11189         if (r->object_dn) {
11190                 ndr_print_string(ndr, "object_dn", r->object_dn);
11191         }
11192         ndr->depth--;
11193         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);
11194         ndr_print_ptr(ndr, "binary", r->binary);
11195         ndr->depth++;
11196         if (r->binary) {
11197                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11198         }
11199         ndr->depth--;
11200         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11201         ndr_print_NTTIME(ndr, "created", r->created);
11202         ndr_print_uint32(ndr, "version", r->version);
11203         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11204         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11205         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11206         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11207         ndr->depth--;
11208 }
11209
11210 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
11211 {
11212         uint32_t cntr_array_0;
11213         if (ndr_flags & NDR_SCALARS) {
11214                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11215                 NDR_CHECK(ndr_push_align(ndr, 8));
11216                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11217                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11218                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11219                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11220                 }
11221                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11222         }
11223         if (ndr_flags & NDR_BUFFERS) {
11224                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11225                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11226                 }
11227         }
11228         return NDR_ERR_SUCCESS;
11229 }
11230
11231 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
11232 {
11233         uint32_t cntr_array_0;
11234         TALLOC_CTX *_mem_save_array_0;
11235         if (ndr_flags & NDR_SCALARS) {
11236                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11237                 NDR_CHECK(ndr_pull_align(ndr, 8));
11238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11239                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11240                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11241                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11242                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11243                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11244                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11245                 }
11246                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11247                 if (r->array) {
11248                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11249                 }
11250                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11251         }
11252         if (ndr_flags & NDR_BUFFERS) {
11253                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11254                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11255                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11256                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11257                 }
11258                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11259         }
11260         return NDR_ERR_SUCCESS;
11261 }
11262
11263 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
11264 {
11265         uint32_t cntr_array_0;
11266         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaDataCtr");
11267         ndr->depth++;
11268         ndr_print_uint32(ndr, "count", r->count);
11269         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11270         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11271         ndr->depth++;
11272         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11273                 char *idx_0=NULL;
11274                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11275                         ndr_print_drsuapi_DsReplicaAttrValMetaData(ndr, "array", &r->array[cntr_array_0]);
11276                         free(idx_0);
11277                 }
11278         }
11279         ndr->depth--;
11280         ndr->depth--;
11281 }
11282
11283 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2Ctr *r)
11284 {
11285         uint32_t cntr_array_0;
11286         if (ndr_flags & NDR_SCALARS) {
11287                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11288                 NDR_CHECK(ndr_push_align(ndr, 8));
11289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11290                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11291                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11292                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11293                 }
11294                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11295         }
11296         if (ndr_flags & NDR_BUFFERS) {
11297         }
11298         return NDR_ERR_SUCCESS;
11299 }
11300
11301 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
11302 {
11303         uint32_t cntr_array_0;
11304         TALLOC_CTX *_mem_save_array_0;
11305         if (ndr_flags & NDR_SCALARS) {
11306                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11307                 NDR_CHECK(ndr_pull_align(ndr, 8));
11308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11309                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11310                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11311                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11312                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11313                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11314                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11315                 }
11316                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11317                 if (r->array) {
11318                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11319                 }
11320                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11321         }
11322         if (ndr_flags & NDR_BUFFERS) {
11323         }
11324         return NDR_ERR_SUCCESS;
11325 }
11326
11327 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2Ctr *r)
11328 {
11329         uint32_t cntr_array_0;
11330         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2Ctr");
11331         ndr->depth++;
11332         ndr_print_uint32(ndr, "count", r->count);
11333         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11334         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11335         ndr->depth++;
11336         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11337                 char *idx_0=NULL;
11338                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11339                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "array", &r->array[cntr_array_0]);
11340                         free(idx_0);
11341                 }
11342         }
11343         ndr->depth--;
11344         ndr->depth--;
11345 }
11346
11347 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3 *r)
11348 {
11349         if (ndr_flags & NDR_SCALARS) {
11350                 NDR_CHECK(ndr_push_align(ndr, 8));
11351                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11352                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
11353                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
11354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
11355                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11356         }
11357         if (ndr_flags & NDR_BUFFERS) {
11358                 if (r->source_dsa_obj_dn) {
11359                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11360                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11361                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11362                         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));
11363                 }
11364         }
11365         return NDR_ERR_SUCCESS;
11366 }
11367
11368 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
11369 {
11370         uint32_t _ptr_source_dsa_obj_dn;
11371         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
11372         if (ndr_flags & NDR_SCALARS) {
11373                 NDR_CHECK(ndr_pull_align(ndr, 8));
11374                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11375                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
11376                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
11377                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
11378                 if (_ptr_source_dsa_obj_dn) {
11379                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
11380                 } else {
11381                         r->source_dsa_obj_dn = NULL;
11382                 }
11383                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11384         }
11385         if (ndr_flags & NDR_BUFFERS) {
11386                 if (r->source_dsa_obj_dn) {
11387                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11388                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
11389                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
11390                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
11391                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
11392                                 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));
11393                         }
11394                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
11395                         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));
11396                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
11397                 }
11398         }
11399         return NDR_ERR_SUCCESS;
11400 }
11401
11402 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3 *r)
11403 {
11404         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3");
11405         ndr->depth++;
11406         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
11407         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
11408         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
11409         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11410         ndr->depth++;
11411         if (r->source_dsa_obj_dn) {
11412                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11413         }
11414         ndr->depth--;
11415         ndr->depth--;
11416 }
11417
11418 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3Ctr *r)
11419 {
11420         uint32_t cntr_array_0;
11421         if (ndr_flags & NDR_SCALARS) {
11422                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11423                 NDR_CHECK(ndr_push_align(ndr, 8));
11424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11425                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11426                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11427                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11428                 }
11429                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11430         }
11431         if (ndr_flags & NDR_BUFFERS) {
11432                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11433                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11434                 }
11435         }
11436         return NDR_ERR_SUCCESS;
11437 }
11438
11439 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
11440 {
11441         uint32_t cntr_array_0;
11442         TALLOC_CTX *_mem_save_array_0;
11443         if (ndr_flags & NDR_SCALARS) {
11444                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11445                 NDR_CHECK(ndr_pull_align(ndr, 8));
11446                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11447                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11448                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11449                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11450                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11451                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11452                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11453                 }
11454                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11455                 if (r->array) {
11456                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11457                 }
11458                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11459         }
11460         if (ndr_flags & NDR_BUFFERS) {
11461                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11462                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11463                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11464                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11465                 }
11466                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11467         }
11468         return NDR_ERR_SUCCESS;
11469 }
11470
11471 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3Ctr *r)
11472 {
11473         uint32_t cntr_array_0;
11474         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3Ctr");
11475         ndr->depth++;
11476         ndr_print_uint32(ndr, "count", r->count);
11477         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11478         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11479         ndr->depth++;
11480         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11481                 char *idx_0=NULL;
11482                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11483                         ndr_print_drsuapi_DsReplicaCursor3(ndr, "array", &r->array[cntr_array_0]);
11484                         free(idx_0);
11485                 }
11486         }
11487         ndr->depth--;
11488         ndr->depth--;
11489 }
11490
11491 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2 *r)
11492 {
11493         if (ndr_flags & NDR_SCALARS) {
11494                 NDR_CHECK(ndr_push_align(ndr, 8));
11495                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11496                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11497                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11498                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11499                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11500                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11501                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11502                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11503         }
11504         if (ndr_flags & NDR_BUFFERS) {
11505                 if (r->attribute_name) {
11506                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11507                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11508                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11509                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11510                 }
11511                 if (r->originating_dsa_dn) {
11512                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11513                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11514                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11515                         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));
11516                 }
11517         }
11518         return NDR_ERR_SUCCESS;
11519 }
11520
11521 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
11522 {
11523         uint32_t _ptr_attribute_name;
11524         TALLOC_CTX *_mem_save_attribute_name_0;
11525         uint32_t _ptr_originating_dsa_dn;
11526         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11527         if (ndr_flags & NDR_SCALARS) {
11528                 NDR_CHECK(ndr_pull_align(ndr, 8));
11529                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11530                 if (_ptr_attribute_name) {
11531                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11532                 } else {
11533                         r->attribute_name = NULL;
11534                 }
11535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11536                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11537                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11538                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11539                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11540                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11541                 if (_ptr_originating_dsa_dn) {
11542                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11543                 } else {
11544                         r->originating_dsa_dn = NULL;
11545                 }
11546                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11547         }
11548         if (ndr_flags & NDR_BUFFERS) {
11549                 if (r->attribute_name) {
11550                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11551                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11552                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11553                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11554                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11555                                 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));
11556                         }
11557                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11558                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11560                 }
11561                 if (r->originating_dsa_dn) {
11562                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11563                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11564                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11565                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11566                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11567                                 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));
11568                         }
11569                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11570                         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));
11571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11572                 }
11573         }
11574         return NDR_ERR_SUCCESS;
11575 }
11576
11577 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2 *r)
11578 {
11579         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2");
11580         ndr->depth++;
11581         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11582         ndr->depth++;
11583         if (r->attribute_name) {
11584                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11585         }
11586         ndr->depth--;
11587         ndr_print_uint32(ndr, "version", r->version);
11588         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11589         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11590         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11591         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11592         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11593         ndr->depth++;
11594         if (r->originating_dsa_dn) {
11595                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11596         }
11597         ndr->depth--;
11598         ndr->depth--;
11599 }
11600
11601 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11602 {
11603         uint32_t cntr_array_0;
11604         if (ndr_flags & NDR_SCALARS) {
11605                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11606                 NDR_CHECK(ndr_push_align(ndr, 8));
11607                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11608                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11609                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11610                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11611                 }
11612                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11613         }
11614         if (ndr_flags & NDR_BUFFERS) {
11615                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11616                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11617                 }
11618         }
11619         return NDR_ERR_SUCCESS;
11620 }
11621
11622 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11623 {
11624         uint32_t cntr_array_0;
11625         TALLOC_CTX *_mem_save_array_0;
11626         if (ndr_flags & NDR_SCALARS) {
11627                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11628                 NDR_CHECK(ndr_pull_align(ndr, 8));
11629                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11630                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11631                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11632                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11633                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11634                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11635                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11636                 }
11637                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11638                 if (r->array) {
11639                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11640                 }
11641                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11642         }
11643         if (ndr_flags & NDR_BUFFERS) {
11644                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11645                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11646                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11647                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11648                 }
11649                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11650         }
11651         return NDR_ERR_SUCCESS;
11652 }
11653
11654 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11655 {
11656         uint32_t cntr_array_0;
11657         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2Ctr");
11658         ndr->depth++;
11659         ndr_print_uint32(ndr, "count", r->count);
11660         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11661         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11662         ndr->depth++;
11663         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11664                 char *idx_0=NULL;
11665                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11666                         ndr_print_drsuapi_DsReplicaObjMetaData2(ndr, "array", &r->array[cntr_array_0]);
11667                         free(idx_0);
11668                 }
11669         }
11670         ndr->depth--;
11671         ndr->depth--;
11672 }
11673
11674 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11675 {
11676         if (ndr_flags & NDR_SCALARS) {
11677                 NDR_CHECK(ndr_push_align(ndr, 8));
11678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11680                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11682                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11683                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11685                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11686                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11687                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11688                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11689                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11690                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11691         }
11692         if (ndr_flags & NDR_BUFFERS) {
11693                 if (r->attribute_name) {
11694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11695                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11696                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11697                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11698                 }
11699                 if (r->object_dn) {
11700                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11701                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11702                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11703                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11704                 }
11705                 if (r->binary) {
11706                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11707                 }
11708                 if (r->originating_dsa_dn) {
11709                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11710                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11711                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11712                         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));
11713                 }
11714         }
11715         return NDR_ERR_SUCCESS;
11716 }
11717
11718 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
11719 {
11720         uint32_t _ptr_attribute_name;
11721         TALLOC_CTX *_mem_save_attribute_name_0;
11722         uint32_t _ptr_object_dn;
11723         TALLOC_CTX *_mem_save_object_dn_0;
11724         uint32_t _ptr_binary;
11725         TALLOC_CTX *_mem_save_binary_0;
11726         uint32_t _ptr_originating_dsa_dn;
11727         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11728         if (ndr_flags & NDR_SCALARS) {
11729                 NDR_CHECK(ndr_pull_align(ndr, 8));
11730                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11731                 if (_ptr_attribute_name) {
11732                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11733                 } else {
11734                         r->attribute_name = NULL;
11735                 }
11736                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11737                 if (_ptr_object_dn) {
11738                         NDR_PULL_ALLOC(ndr, r->object_dn);
11739                 } else {
11740                         r->object_dn = NULL;
11741                 }
11742                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11743                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11744                 if (_ptr_binary) {
11745                         NDR_PULL_ALLOC(ndr, r->binary);
11746                 } else {
11747                         r->binary = NULL;
11748                 }
11749                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11750                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11751                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11752                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11753                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11754                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11755                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11756                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11757                 if (_ptr_originating_dsa_dn) {
11758                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11759                 } else {
11760                         r->originating_dsa_dn = NULL;
11761                 }
11762                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11763         }
11764         if (ndr_flags & NDR_BUFFERS) {
11765                 if (r->attribute_name) {
11766                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11767                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11768                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11769                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11770                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11771                                 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));
11772                         }
11773                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11774                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11776                 }
11777                 if (r->object_dn) {
11778                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11779                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11780                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11781                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11782                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11783                                 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));
11784                         }
11785                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11786                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11787                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11788                 }
11789                 if (r->binary) {
11790                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11791                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11792                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11793                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11794                 }
11795                 if (r->originating_dsa_dn) {
11796                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11797                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11798                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11799                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11800                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11801                                 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));
11802                         }
11803                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11804                         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));
11805                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11806                 }
11807         }
11808         return NDR_ERR_SUCCESS;
11809 }
11810
11811 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11812 {
11813         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2");
11814         ndr->depth++;
11815         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11816         ndr->depth++;
11817         if (r->attribute_name) {
11818                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11819         }
11820         ndr->depth--;
11821         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11822         ndr->depth++;
11823         if (r->object_dn) {
11824                 ndr_print_string(ndr, "object_dn", r->object_dn);
11825         }
11826         ndr->depth--;
11827         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);
11828         ndr_print_ptr(ndr, "binary", r->binary);
11829         ndr->depth++;
11830         if (r->binary) {
11831                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11832         }
11833         ndr->depth--;
11834         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11835         ndr_print_NTTIME(ndr, "created", r->created);
11836         ndr_print_uint32(ndr, "version", r->version);
11837         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11838         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11839         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11840         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11841         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11842         ndr->depth++;
11843         if (r->originating_dsa_dn) {
11844                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11845         }
11846         ndr->depth--;
11847         ndr->depth--;
11848 }
11849
11850 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11851 {
11852         uint32_t cntr_array_0;
11853         if (ndr_flags & NDR_SCALARS) {
11854                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11855                 NDR_CHECK(ndr_push_align(ndr, 8));
11856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11857                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11858                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11859                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11860                 }
11861                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11862         }
11863         if (ndr_flags & NDR_BUFFERS) {
11864                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11865                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11866                 }
11867         }
11868         return NDR_ERR_SUCCESS;
11869 }
11870
11871 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11872 {
11873         uint32_t cntr_array_0;
11874         TALLOC_CTX *_mem_save_array_0;
11875         if (ndr_flags & NDR_SCALARS) {
11876                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11877                 NDR_CHECK(ndr_pull_align(ndr, 8));
11878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11879                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11880                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11881                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11882                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11883                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11884                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11885                 }
11886                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11887                 if (r->array) {
11888                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11889                 }
11890                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11891         }
11892         if (ndr_flags & NDR_BUFFERS) {
11893                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11894                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11895                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11896                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11897                 }
11898                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11899         }
11900         return NDR_ERR_SUCCESS;
11901 }
11902
11903 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11904 {
11905         uint32_t cntr_array_0;
11906         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2Ctr");
11907         ndr->depth++;
11908         ndr_print_uint32(ndr, "count", r->count);
11909         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11910         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11911         ndr->depth++;
11912         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11913                 char *idx_0=NULL;
11914                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11915                         ndr_print_drsuapi_DsReplicaAttrValMetaData2(ndr, "array", &r->array[cntr_array_0]);
11916                         free(idx_0);
11917                 }
11918         }
11919         ndr->depth--;
11920         ndr->depth--;
11921 }
11922
11923 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04 *r)
11924 {
11925         if (ndr_flags & NDR_SCALARS) {
11926                 NDR_CHECK(ndr_push_align(ndr, 8));
11927                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u1));
11928                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11929                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11930                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11931                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->bind_time));
11932                 {
11933                         uint32_t _flags_save_ipv4address = ndr->flags;
11934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11935                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
11936                         ndr->flags = _flags_save_ipv4address;
11937                 }
11938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11939                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11940         }
11941         if (ndr_flags & NDR_BUFFERS) {
11942         }
11943         return NDR_ERR_SUCCESS;
11944 }
11945
11946 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04 *r)
11947 {
11948         if (ndr_flags & NDR_SCALARS) {
11949                 NDR_CHECK(ndr_pull_align(ndr, 8));
11950                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u1));
11951                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11952                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11953                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11954                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->bind_time));
11955                 {
11956                         uint32_t _flags_save_ipv4address = ndr->flags;
11957                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11958                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
11959                         ndr->flags = _flags_save_ipv4address;
11960                 }
11961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11962                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11963         }
11964         if (ndr_flags & NDR_BUFFERS) {
11965         }
11966         return NDR_ERR_SUCCESS;
11967 }
11968
11969 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04 *r)
11970 {
11971         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04");
11972         ndr->depth++;
11973         ndr_print_hyper(ndr, "u1", r->u1);
11974         ndr_print_uint32(ndr, "u2", r->u2);
11975         ndr_print_uint32(ndr, "u3", r->u3);
11976         ndr_print_GUID(ndr, "bind_guid", &r->bind_guid);
11977         ndr_print_NTTIME_1sec(ndr, "bind_time", r->bind_time);
11978         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
11979         ndr_print_uint32(ndr, "u5", r->u5);
11980         ndr->depth--;
11981 }
11982
11983 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04Ctr *r)
11984 {
11985         uint32_t cntr_array_0;
11986         if (ndr_flags & NDR_SCALARS) {
11987                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11988                 NDR_CHECK(ndr_push_align(ndr, 8));
11989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11990                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11991                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11992                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11993                 }
11994                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11995         }
11996         if (ndr_flags & NDR_BUFFERS) {
11997         }
11998         return NDR_ERR_SUCCESS;
11999 }
12000
12001 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
12002 {
12003         uint32_t cntr_array_0;
12004         TALLOC_CTX *_mem_save_array_0;
12005         if (ndr_flags & NDR_SCALARS) {
12006                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
12007                 NDR_CHECK(ndr_pull_align(ndr, 8));
12008                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
12009                 if (r->count > 10000) {
12010                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12011                 }
12012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
12013                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
12014                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12015                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12016                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12017                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
12018                 }
12019                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12020                 if (r->array) {
12021                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
12022                 }
12023                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12024         }
12025         if (ndr_flags & NDR_BUFFERS) {
12026         }
12027         return NDR_ERR_SUCCESS;
12028 }
12029
12030 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04Ctr *r)
12031 {
12032         uint32_t cntr_array_0;
12033         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04Ctr");
12034         ndr->depth++;
12035         ndr_print_uint32(ndr, "count", r->count);
12036         ndr_print_uint32(ndr, "reserved", r->reserved);
12037         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
12038         ndr->depth++;
12039         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
12040                 char *idx_0=NULL;
12041                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
12042                         ndr_print_drsuapi_DsReplicaConnection04(ndr, "array", &r->array[cntr_array_0]);
12043                         free(idx_0);
12044                 }
12045         }
12046         ndr->depth--;
12047         ndr->depth--;
12048 }
12049
12050 static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06 *r)
12051 {
12052         if (ndr_flags & NDR_SCALARS) {
12053                 NDR_CHECK(ndr_push_align(ndr, 8));
12054                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str1));
12055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u1));
12056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
12057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
12058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u4));
12059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
12060                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
12061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
12062                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12063         }
12064         if (ndr_flags & NDR_BUFFERS) {
12065                 if (r->str1) {
12066                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
12067                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
12068                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
12069                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12070                 }
12071         }
12072         return NDR_ERR_SUCCESS;
12073 }
12074
12075 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
12076 {
12077         uint32_t _ptr_str1;
12078         TALLOC_CTX *_mem_save_str1_0;
12079         if (ndr_flags & NDR_SCALARS) {
12080                 NDR_CHECK(ndr_pull_align(ndr, 8));
12081                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str1));
12082                 if (_ptr_str1) {
12083                         NDR_PULL_ALLOC(ndr, r->str1);
12084                 } else {
12085                         r->str1 = NULL;
12086                 }
12087                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
12088                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
12089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
12090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u4));
12091                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
12092                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
12093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
12094                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12095         }
12096         if (ndr_flags & NDR_BUFFERS) {
12097                 if (r->str1) {
12098                         _mem_save_str1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12099                         NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
12100                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
12101                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
12102                         if (ndr_get_array_length(ndr, &r->str1) > ndr_get_array_size(ndr, &r->str1)) {
12103                                 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));
12104                         }
12105                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t)));
12106                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t), CH_UTF16));
12107                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
12108                 }
12109         }
12110         return NDR_ERR_SUCCESS;
12111 }
12112
12113 _PUBLIC_ void ndr_print_drsuapi_DsReplica06(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06 *r)
12114 {
12115         ndr_print_struct(ndr, name, "drsuapi_DsReplica06");
12116         ndr->depth++;
12117         ndr_print_ptr(ndr, "str1", r->str1);
12118         ndr->depth++;
12119         if (r->str1) {
12120                 ndr_print_string(ndr, "str1", r->str1);
12121         }
12122         ndr->depth--;
12123         ndr_print_uint32(ndr, "u1", r->u1);
12124         ndr_print_uint32(ndr, "u2", r->u2);
12125         ndr_print_uint32(ndr, "u3", r->u3);
12126         ndr_print_uint32(ndr, "u4", r->u4);
12127         ndr_print_uint32(ndr, "u5", r->u5);
12128         ndr_print_hyper(ndr, "u6", r->u6);
12129         ndr_print_uint32(ndr, "u7", r->u7);
12130         ndr->depth--;
12131 }
12132
12133 static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06Ctr *r)
12134 {
12135         uint32_t cntr_array_0;
12136         if (ndr_flags & NDR_SCALARS) {
12137                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
12138                 NDR_CHECK(ndr_push_align(ndr, 8));
12139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12140                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
12141                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12142                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
12143                 }
12144                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12145         }
12146         if (ndr_flags & NDR_BUFFERS) {
12147                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12148                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
12149                 }
12150         }
12151         return NDR_ERR_SUCCESS;
12152 }
12153
12154 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *r)
12155 {
12156         uint32_t cntr_array_0;
12157         TALLOC_CTX *_mem_save_array_0;
12158         if (ndr_flags & NDR_SCALARS) {
12159                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
12160                 NDR_CHECK(ndr_pull_align(ndr, 8));
12161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
12162                 if (r->count > 256) {
12163                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12164                 }
12165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
12166                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
12167                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12168                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12169                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12170                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
12171                 }
12172                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12173                 if (r->array) {
12174                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
12175                 }
12176                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12177         }
12178         if (ndr_flags & NDR_BUFFERS) {
12179                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12180                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12181                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12182                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
12183                 }
12184                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12185         }
12186         return NDR_ERR_SUCCESS;
12187 }
12188
12189 _PUBLIC_ void ndr_print_drsuapi_DsReplica06Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06Ctr *r)
12190 {
12191         uint32_t cntr_array_0;
12192         ndr_print_struct(ndr, name, "drsuapi_DsReplica06Ctr");
12193         ndr->depth++;
12194         ndr_print_uint32(ndr, "count", r->count);
12195         ndr_print_uint32(ndr, "reserved", r->reserved);
12196         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
12197         ndr->depth++;
12198         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
12199                 char *idx_0=NULL;
12200                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
12201                         ndr_print_drsuapi_DsReplica06(ndr, "array", &r->array[cntr_array_0]);
12202                         free(idx_0);
12203                 }
12204         }
12205         ndr->depth--;
12206         ndr->depth--;
12207 }
12208
12209 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaInfo *r)
12210 {
12211         if (ndr_flags & NDR_SCALARS) {
12212                 int level = ndr_push_get_switch_value(ndr, r);
12213                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
12214                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12215                 switch (level) {
12216                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12217                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
12218                         break; }
12219
12220                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12221                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors));
12222                         break; }
12223
12224                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12225                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata));
12226                         break; }
12227
12228                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12229                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connectfailures));
12230                         break; }
12231
12232                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12233                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linkfailures));
12234                         break; }
12235
12236                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12237                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pendingops));
12238                         break; }
12239
12240                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12241                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata));
12242                         break; }
12243
12244                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12245                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors2));
12246                         break; }
12247
12248                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12249                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors3));
12250                         break; }
12251
12252                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12253                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata2));
12254                         break; }
12255
12256                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12257                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata2));
12258                         break; }
12259
12260                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
12261                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours02));
12262                         break; }
12263
12264                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
12265                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connections04));
12266                         break; }
12267
12268                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
12269                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors05));
12270                         break; }
12271
12272                         case DRSUAPI_DS_REPLICA_INFO_06: {
12273                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->i06));
12274                         break; }
12275
12276                         default:
12277                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12278                 }
12279         }
12280         if (ndr_flags & NDR_BUFFERS) {
12281                 int level = ndr_push_get_switch_value(ndr, r);
12282                 switch (level) {
12283                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12284                                 if (r->neighbours) {
12285                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12286                                 }
12287                         break;
12288
12289                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12290                                 if (r->cursors) {
12291                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12292                                 }
12293                         break;
12294
12295                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12296                                 if (r->objmetadata) {
12297                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12298                                 }
12299                         break;
12300
12301                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12302                                 if (r->connectfailures) {
12303                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12304                                 }
12305                         break;
12306
12307                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12308                                 if (r->linkfailures) {
12309                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12310                                 }
12311                         break;
12312
12313                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12314                                 if (r->pendingops) {
12315                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12316                                 }
12317                         break;
12318
12319                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12320                                 if (r->attrvalmetadata) {
12321                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12322                                 }
12323                         break;
12324
12325                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12326                                 if (r->cursors2) {
12327                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12328                                 }
12329                         break;
12330
12331                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12332                                 if (r->cursors3) {
12333                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12334                                 }
12335                         break;
12336
12337                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12338                                 if (r->objmetadata2) {
12339                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12340                                 }
12341                         break;
12342
12343                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12344                                 if (r->attrvalmetadata2) {
12345                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12346                                 }
12347                         break;
12348
12349                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12350                                 if (r->neighbours02) {
12351                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12352                                 }
12353                         break;
12354
12355                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12356                                 if (r->connections04) {
12357                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12358                                 }
12359                         break;
12360
12361                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12362                                 if (r->cursors05) {
12363                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12364                                 }
12365                         break;
12366
12367                         case DRSUAPI_DS_REPLICA_INFO_06:
12368                                 if (r->i06) {
12369                                         NDR_CHECK(ndr_push_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12370                                 }
12371                         break;
12372
12373                         default:
12374                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12375                 }
12376         }
12377         return NDR_ERR_SUCCESS;
12378 }
12379
12380 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaInfo *r)
12381 {
12382         int level;
12383         uint32_t _level;
12384         TALLOC_CTX *_mem_save_neighbours_0;
12385         TALLOC_CTX *_mem_save_cursors_0;
12386         TALLOC_CTX *_mem_save_objmetadata_0;
12387         TALLOC_CTX *_mem_save_connectfailures_0;
12388         TALLOC_CTX *_mem_save_linkfailures_0;
12389         TALLOC_CTX *_mem_save_pendingops_0;
12390         TALLOC_CTX *_mem_save_attrvalmetadata_0;
12391         TALLOC_CTX *_mem_save_cursors2_0;
12392         TALLOC_CTX *_mem_save_cursors3_0;
12393         TALLOC_CTX *_mem_save_objmetadata2_0;
12394         TALLOC_CTX *_mem_save_attrvalmetadata2_0;
12395         TALLOC_CTX *_mem_save_neighbours02_0;
12396         TALLOC_CTX *_mem_save_connections04_0;
12397         TALLOC_CTX *_mem_save_cursors05_0;
12398         TALLOC_CTX *_mem_save_i06_0;
12399         level = ndr_pull_get_switch_value(ndr, r);
12400         if (ndr_flags & NDR_SCALARS) {
12401                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12402                 if (_level != level) {
12403                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12404                 }
12405                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12406                 switch (level) {
12407                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12408                                 uint32_t _ptr_neighbours;
12409                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
12410                                 if (_ptr_neighbours) {
12411                                         NDR_PULL_ALLOC(ndr, r->neighbours);
12412                                 } else {
12413                                         r->neighbours = NULL;
12414                                 }
12415                         break; }
12416
12417                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12418                                 uint32_t _ptr_cursors;
12419                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
12420                                 if (_ptr_cursors) {
12421                                         NDR_PULL_ALLOC(ndr, r->cursors);
12422                                 } else {
12423                                         r->cursors = NULL;
12424                                 }
12425                         break; }
12426
12427                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12428                                 uint32_t _ptr_objmetadata;
12429                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
12430                                 if (_ptr_objmetadata) {
12431                                         NDR_PULL_ALLOC(ndr, r->objmetadata);
12432                                 } else {
12433                                         r->objmetadata = NULL;
12434                                 }
12435                         break; }
12436
12437                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12438                                 uint32_t _ptr_connectfailures;
12439                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
12440                                 if (_ptr_connectfailures) {
12441                                         NDR_PULL_ALLOC(ndr, r->connectfailures);
12442                                 } else {
12443                                         r->connectfailures = NULL;
12444                                 }
12445                         break; }
12446
12447                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12448                                 uint32_t _ptr_linkfailures;
12449                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
12450                                 if (_ptr_linkfailures) {
12451                                         NDR_PULL_ALLOC(ndr, r->linkfailures);
12452                                 } else {
12453                                         r->linkfailures = NULL;
12454                                 }
12455                         break; }
12456
12457                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12458                                 uint32_t _ptr_pendingops;
12459                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
12460                                 if (_ptr_pendingops) {
12461                                         NDR_PULL_ALLOC(ndr, r->pendingops);
12462                                 } else {
12463                                         r->pendingops = NULL;
12464                                 }
12465                         break; }
12466
12467                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12468                                 uint32_t _ptr_attrvalmetadata;
12469                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
12470                                 if (_ptr_attrvalmetadata) {
12471                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
12472                                 } else {
12473                                         r->attrvalmetadata = NULL;
12474                                 }
12475                         break; }
12476
12477                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12478                                 uint32_t _ptr_cursors2;
12479                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
12480                                 if (_ptr_cursors2) {
12481                                         NDR_PULL_ALLOC(ndr, r->cursors2);
12482                                 } else {
12483                                         r->cursors2 = NULL;
12484                                 }
12485                         break; }
12486
12487                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12488                                 uint32_t _ptr_cursors3;
12489                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
12490                                 if (_ptr_cursors3) {
12491                                         NDR_PULL_ALLOC(ndr, r->cursors3);
12492                                 } else {
12493                                         r->cursors3 = NULL;
12494                                 }
12495                         break; }
12496
12497                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12498                                 uint32_t _ptr_objmetadata2;
12499                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
12500                                 if (_ptr_objmetadata2) {
12501                                         NDR_PULL_ALLOC(ndr, r->objmetadata2);
12502                                 } else {
12503                                         r->objmetadata2 = NULL;
12504                                 }
12505                         break; }
12506
12507                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12508                                 uint32_t _ptr_attrvalmetadata2;
12509                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
12510                                 if (_ptr_attrvalmetadata2) {
12511                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
12512                                 } else {
12513                                         r->attrvalmetadata2 = NULL;
12514                                 }
12515                         break; }
12516
12517                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
12518                                 uint32_t _ptr_neighbours02;
12519                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours02));
12520                                 if (_ptr_neighbours02) {
12521                                         NDR_PULL_ALLOC(ndr, r->neighbours02);
12522                                 } else {
12523                                         r->neighbours02 = NULL;
12524                                 }
12525                         break; }
12526
12527                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
12528                                 uint32_t _ptr_connections04;
12529                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connections04));
12530                                 if (_ptr_connections04) {
12531                                         NDR_PULL_ALLOC(ndr, r->connections04);
12532                                 } else {
12533                                         r->connections04 = NULL;
12534                                 }
12535                         break; }
12536
12537                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
12538                                 uint32_t _ptr_cursors05;
12539                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors05));
12540                                 if (_ptr_cursors05) {
12541                                         NDR_PULL_ALLOC(ndr, r->cursors05);
12542                                 } else {
12543                                         r->cursors05 = NULL;
12544                                 }
12545                         break; }
12546
12547                         case DRSUAPI_DS_REPLICA_INFO_06: {
12548                                 uint32_t _ptr_i06;
12549                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_i06));
12550                                 if (_ptr_i06) {
12551                                         NDR_PULL_ALLOC(ndr, r->i06);
12552                                 } else {
12553                                         r->i06 = NULL;
12554                                 }
12555                         break; }
12556
12557                         default:
12558                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12559                 }
12560         }
12561         if (ndr_flags & NDR_BUFFERS) {
12562                 switch (level) {
12563                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12564                                 if (r->neighbours) {
12565                                         _mem_save_neighbours_0 = NDR_PULL_GET_MEM_CTX(ndr);
12566                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours, 0);
12567                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12568                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours_0, 0);
12569                                 }
12570                         break;
12571
12572                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12573                                 if (r->cursors) {
12574                                         _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
12575                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
12576                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12577                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
12578                                 }
12579                         break;
12580
12581                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12582                                 if (r->objmetadata) {
12583                                         _mem_save_objmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12584                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata, 0);
12585                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12586                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata_0, 0);
12587                                 }
12588                         break;
12589
12590                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12591                                 if (r->connectfailures) {
12592                                         _mem_save_connectfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12593                                         NDR_PULL_SET_MEM_CTX(ndr, r->connectfailures, 0);
12594                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12595                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connectfailures_0, 0);
12596                                 }
12597                         break;
12598
12599                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12600                                 if (r->linkfailures) {
12601                                         _mem_save_linkfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12602                                         NDR_PULL_SET_MEM_CTX(ndr, r->linkfailures, 0);
12603                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12604                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linkfailures_0, 0);
12605                                 }
12606                         break;
12607
12608                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12609                                 if (r->pendingops) {
12610                                         _mem_save_pendingops_0 = NDR_PULL_GET_MEM_CTX(ndr);
12611                                         NDR_PULL_SET_MEM_CTX(ndr, r->pendingops, 0);
12612                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12613                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pendingops_0, 0);
12614                                 }
12615                         break;
12616
12617                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12618                                 if (r->attrvalmetadata) {
12619                                         _mem_save_attrvalmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12620                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata, 0);
12621                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12622                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata_0, 0);
12623                                 }
12624                         break;
12625
12626                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12627                                 if (r->cursors2) {
12628                                         _mem_save_cursors2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12629                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors2, 0);
12630                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12631                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors2_0, 0);
12632                                 }
12633                         break;
12634
12635                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12636                                 if (r->cursors3) {
12637                                         _mem_save_cursors3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12638                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors3, 0);
12639                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12640                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors3_0, 0);
12641                                 }
12642                         break;
12643
12644                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12645                                 if (r->objmetadata2) {
12646                                         _mem_save_objmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12647                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata2, 0);
12648                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12649                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata2_0, 0);
12650                                 }
12651                         break;
12652
12653                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12654                                 if (r->attrvalmetadata2) {
12655                                         _mem_save_attrvalmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12656                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata2, 0);
12657                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12658                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata2_0, 0);
12659                                 }
12660                         break;
12661
12662                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12663                                 if (r->neighbours02) {
12664                                         _mem_save_neighbours02_0 = NDR_PULL_GET_MEM_CTX(ndr);
12665                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours02, 0);
12666                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12667                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours02_0, 0);
12668                                 }
12669                         break;
12670
12671                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12672                                 if (r->connections04) {
12673                                         _mem_save_connections04_0 = NDR_PULL_GET_MEM_CTX(ndr);
12674                                         NDR_PULL_SET_MEM_CTX(ndr, r->connections04, 0);
12675                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12676                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connections04_0, 0);
12677                                 }
12678                         break;
12679
12680                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12681                                 if (r->cursors05) {
12682                                         _mem_save_cursors05_0 = NDR_PULL_GET_MEM_CTX(ndr);
12683                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors05, 0);
12684                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12685                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors05_0, 0);
12686                                 }
12687                         break;
12688
12689                         case DRSUAPI_DS_REPLICA_INFO_06:
12690                                 if (r->i06) {
12691                                         _mem_save_i06_0 = NDR_PULL_GET_MEM_CTX(ndr);
12692                                         NDR_PULL_SET_MEM_CTX(ndr, r->i06, 0);
12693                                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12694                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_i06_0, 0);
12695                                 }
12696                         break;
12697
12698                         default:
12699                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12700                 }
12701         }
12702         return NDR_ERR_SUCCESS;
12703 }
12704
12705 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaInfo *r)
12706 {
12707         int level;
12708         level = ndr_print_get_switch_value(ndr, r);
12709         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaInfo");
12710         switch (level) {
12711                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12712                         ndr_print_ptr(ndr, "neighbours", r->neighbours);
12713                         ndr->depth++;
12714                         if (r->neighbours) {
12715                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours", r->neighbours);
12716                         }
12717                         ndr->depth--;
12718                 break;
12719
12720                 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12721                         ndr_print_ptr(ndr, "cursors", r->cursors);
12722                         ndr->depth++;
12723                         if (r->cursors) {
12724                                 ndr_print_drsuapi_DsReplicaCursorCtr(ndr, "cursors", r->cursors);
12725                         }
12726                         ndr->depth--;
12727                 break;
12728
12729                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12730                         ndr_print_ptr(ndr, "objmetadata", r->objmetadata);
12731                         ndr->depth++;
12732                         if (r->objmetadata) {
12733                                 ndr_print_drsuapi_DsReplicaObjMetaDataCtr(ndr, "objmetadata", r->objmetadata);
12734                         }
12735                         ndr->depth--;
12736                 break;
12737
12738                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12739                         ndr_print_ptr(ndr, "connectfailures", r->connectfailures);
12740                         ndr->depth++;
12741                         if (r->connectfailures) {
12742                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "connectfailures", r->connectfailures);
12743                         }
12744                         ndr->depth--;
12745                 break;
12746
12747                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12748                         ndr_print_ptr(ndr, "linkfailures", r->linkfailures);
12749                         ndr->depth++;
12750                         if (r->linkfailures) {
12751                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "linkfailures", r->linkfailures);
12752                         }
12753                         ndr->depth--;
12754                 break;
12755
12756                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12757                         ndr_print_ptr(ndr, "pendingops", r->pendingops);
12758                         ndr->depth++;
12759                         if (r->pendingops) {
12760                                 ndr_print_drsuapi_DsReplicaOpCtr(ndr, "pendingops", r->pendingops);
12761                         }
12762                         ndr->depth--;
12763                 break;
12764
12765                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12766                         ndr_print_ptr(ndr, "attrvalmetadata", r->attrvalmetadata);
12767                         ndr->depth++;
12768                         if (r->attrvalmetadata) {
12769                                 ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, "attrvalmetadata", r->attrvalmetadata);
12770                         }
12771                         ndr->depth--;
12772                 break;
12773
12774                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12775                         ndr_print_ptr(ndr, "cursors2", r->cursors2);
12776                         ndr->depth++;
12777                         if (r->cursors2) {
12778                                 ndr_print_drsuapi_DsReplicaCursor2Ctr(ndr, "cursors2", r->cursors2);
12779                         }
12780                         ndr->depth--;
12781                 break;
12782
12783                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12784                         ndr_print_ptr(ndr, "cursors3", r->cursors3);
12785                         ndr->depth++;
12786                         if (r->cursors3) {
12787                                 ndr_print_drsuapi_DsReplicaCursor3Ctr(ndr, "cursors3", r->cursors3);
12788                         }
12789                         ndr->depth--;
12790                 break;
12791
12792                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12793                         ndr_print_ptr(ndr, "objmetadata2", r->objmetadata2);
12794                         ndr->depth++;
12795                         if (r->objmetadata2) {
12796                                 ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(ndr, "objmetadata2", r->objmetadata2);
12797                         }
12798                         ndr->depth--;
12799                 break;
12800
12801                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12802                         ndr_print_ptr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12803                         ndr->depth++;
12804                         if (r->attrvalmetadata2) {
12805                                 ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12806                         }
12807                         ndr->depth--;
12808                 break;
12809
12810                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12811                         ndr_print_ptr(ndr, "neighbours02", r->neighbours02);
12812                         ndr->depth++;
12813                         if (r->neighbours02) {
12814                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours02", r->neighbours02);
12815                         }
12816                         ndr->depth--;
12817                 break;
12818
12819                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12820                         ndr_print_ptr(ndr, "connections04", r->connections04);
12821                         ndr->depth++;
12822                         if (r->connections04) {
12823                                 ndr_print_drsuapi_DsReplicaConnection04Ctr(ndr, "connections04", r->connections04);
12824                         }
12825                         ndr->depth--;
12826                 break;
12827
12828                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12829                         ndr_print_ptr(ndr, "cursors05", r->cursors05);
12830                         ndr->depth++;
12831                         if (r->cursors05) {
12832                                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "cursors05", r->cursors05);
12833                         }
12834                         ndr->depth--;
12835                 break;
12836
12837                 case DRSUAPI_DS_REPLICA_INFO_06:
12838                         ndr_print_ptr(ndr, "i06", r->i06);
12839                         ndr->depth++;
12840                         if (r->i06) {
12841                                 ndr_print_drsuapi_DsReplica06Ctr(ndr, "i06", r->i06);
12842                         }
12843                         ndr->depth--;
12844                 break;
12845
12846                 default:
12847                         ndr_print_bad_level(ndr, name, level);
12848         }
12849 }
12850
12851 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Ctr *r)
12852 {
12853         if (ndr_flags & NDR_SCALARS) {
12854                 int level = ndr_push_get_switch_value(ndr, r);
12855                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12856                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12857                 switch (level) {
12858                         case 1: {
12859                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12860                         break; }
12861
12862                         default:
12863                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12864                 }
12865         }
12866         if (ndr_flags & NDR_BUFFERS) {
12867                 int level = ndr_push_get_switch_value(ndr, r);
12868                 switch (level) {
12869                         case 1:
12870                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12871                         break;
12872
12873                         default:
12874                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12875                 }
12876         }
12877         return NDR_ERR_SUCCESS;
12878 }
12879
12880 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Ctr *r)
12881 {
12882         int level;
12883         int32_t _level;
12884         level = ndr_pull_get_switch_value(ndr, r);
12885         if (ndr_flags & NDR_SCALARS) {
12886                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12887                 if (_level != level) {
12888                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12889                 }
12890                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12891                 switch (level) {
12892                         case 1: {
12893                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12894                         break; }
12895
12896                         default:
12897                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12898                 }
12899         }
12900         if (ndr_flags & NDR_BUFFERS) {
12901                 switch (level) {
12902                         case 1:
12903                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12904                         break;
12905
12906                         default:
12907                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12908                 }
12909         }
12910         return NDR_ERR_SUCCESS;
12911 }
12912
12913 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Ctr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Ctr *r)
12914 {
12915         int level;
12916         level = ndr_print_get_switch_value(ndr, r);
12917         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Ctr");
12918         switch (level) {
12919                 case 1:
12920                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
12921                 break;
12922
12923                 default:
12924                         ndr_print_bad_level(ndr, name, level);
12925         }
12926 }
12927
12928 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMemberships2Request1 *r)
12929 {
12930         uint32_t cntr_req_array_1;
12931         if (ndr_flags & NDR_SCALARS) {
12932                 NDR_CHECK(ndr_push_align(ndr, 5));
12933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12934                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
12935                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12936         }
12937         if (ndr_flags & NDR_BUFFERS) {
12938                 if (r->req_array) {
12939                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
12940                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12941                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
12942                         }
12943                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12944                                 if (r->req_array[cntr_req_array_1]) {
12945                                         NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12946                                 }
12947                         }
12948                 }
12949         }
12950         return NDR_ERR_SUCCESS;
12951 }
12952
12953 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
12954 {
12955         uint32_t _ptr_req_array;
12956         uint32_t cntr_req_array_1;
12957         TALLOC_CTX *_mem_save_req_array_0;
12958         TALLOC_CTX *_mem_save_req_array_1;
12959         TALLOC_CTX *_mem_save_req_array_2;
12960         if (ndr_flags & NDR_SCALARS) {
12961                 NDR_CHECK(ndr_pull_align(ndr, 5));
12962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12963                 if (r->num_req < 1 || r->num_req > 10000) {
12964                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12965                 }
12966                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12967                 if (_ptr_req_array) {
12968                         NDR_PULL_ALLOC(ndr, r->req_array);
12969                 } else {
12970                         r->req_array = NULL;
12971                 }
12972                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12973         }
12974         if (ndr_flags & NDR_BUFFERS) {
12975                 if (r->req_array) {
12976                         _mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12977                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12978                         NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
12979                         NDR_PULL_ALLOC_N(ndr, r->req_array, ndr_get_array_size(ndr, &r->req_array));
12980                         _mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12981                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12982                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12983                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12984                                 if (_ptr_req_array) {
12985                                         NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
12986                                 } else {
12987                                         r->req_array[cntr_req_array_1] = NULL;
12988                                 }
12989                         }
12990                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12991                                 if (r->req_array[cntr_req_array_1]) {
12992                                         _mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
12993                                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
12994                                         NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12995                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_2, 0);
12996                                 }
12997                         }
12998                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_1, 0);
12999                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_0, 0);
13000                 }
13001                 if (r->req_array) {
13002                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->req_array, r->num_req));
13003                 }
13004         }
13005         return NDR_ERR_SUCCESS;
13006 }
13007
13008 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMemberships2Request1 *r)
13009 {
13010         uint32_t cntr_req_array_1;
13011         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2Request1");
13012         ndr->depth++;
13013         ndr_print_uint32(ndr, "num_req", r->num_req);
13014         ndr_print_ptr(ndr, "req_array", r->req_array);
13015         ndr->depth++;
13016         if (r->req_array) {
13017                 ndr->print(ndr, "%s: ARRAY(%d)", "req_array", (int)r->num_req);
13018                 ndr->depth++;
13019                 for (cntr_req_array_1=0;cntr_req_array_1<r->num_req;cntr_req_array_1++) {
13020                         char *idx_1=NULL;
13021                         if (asprintf(&idx_1, "[%d]", cntr_req_array_1) != -1) {
13022                                 ndr_print_ptr(ndr, "req_array", r->req_array[cntr_req_array_1]);
13023                                 ndr->depth++;
13024                                 if (r->req_array[cntr_req_array_1]) {
13025                                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req_array", r->req_array[cntr_req_array_1]);
13026                                 }
13027                                 ndr->depth--;
13028                                 free(idx_1);
13029                         }
13030                 }
13031                 ndr->depth--;
13032         }
13033         ndr->depth--;
13034         ndr->depth--;
13035 }
13036
13037 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Request *r)
13038 {
13039         if (ndr_flags & NDR_SCALARS) {
13040                 int level = ndr_push_get_switch_value(ndr, r);
13041                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13042                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13043                 switch (level) {
13044                         case 1: {
13045                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
13046                         break; }
13047
13048                         default:
13049                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13050                 }
13051         }
13052         if (ndr_flags & NDR_BUFFERS) {
13053                 int level = ndr_push_get_switch_value(ndr, r);
13054                 switch (level) {
13055                         case 1:
13056                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
13057                         break;
13058
13059                         default:
13060                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13061                 }
13062         }
13063         return NDR_ERR_SUCCESS;
13064 }
13065
13066 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Request *r)
13067 {
13068         int level;
13069         int32_t _level;
13070         level = ndr_pull_get_switch_value(ndr, r);
13071         if (ndr_flags & NDR_SCALARS) {
13072                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13073                 if (_level != level) {
13074                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13075                 }
13076                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13077                 switch (level) {
13078                         case 1: {
13079                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
13080                         break; }
13081
13082                         default:
13083                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13084                 }
13085         }
13086         if (ndr_flags & NDR_BUFFERS) {
13087                 switch (level) {
13088                         case 1:
13089                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
13090                         break;
13091
13092                         default:
13093                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13094                 }
13095         }
13096         return NDR_ERR_SUCCESS;
13097 }
13098
13099 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Request *r)
13100 {
13101         int level;
13102         level = ndr_print_get_switch_value(ndr, r);
13103         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Request");
13104         switch (level) {
13105                 case 1:
13106                         ndr_print_drsuapi_DsGetMemberships2Request1(ndr, "req1", &r->req1);
13107                 break;
13108
13109                 default:
13110                         ndr_print_bad_level(ndr, name, level);
13111         }
13112 }
13113
13114 static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsSiteCostInfo *r)
13115 {
13116         if (ndr_flags & NDR_SCALARS) {
13117                 NDR_CHECK(ndr_push_align(ndr, 4));
13118                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
13119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
13120                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
13121         }
13122         if (ndr_flags & NDR_BUFFERS) {
13123         }
13124         return NDR_ERR_SUCCESS;
13125 }
13126
13127 static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsSiteCostInfo *r)
13128 {
13129         if (ndr_flags & NDR_SCALARS) {
13130                 NDR_CHECK(ndr_pull_align(ndr, 4));
13131                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
13132                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
13133                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
13134         }
13135         if (ndr_flags & NDR_BUFFERS) {
13136         }
13137         return NDR_ERR_SUCCESS;
13138 }
13139
13140 _PUBLIC_ void ndr_print_drsuapi_DsSiteCostInfo(struct ndr_print *ndr, const char *name, const struct drsuapi_DsSiteCostInfo *r)
13141 {
13142         ndr_print_struct(ndr, name, "drsuapi_DsSiteCostInfo");
13143         ndr->depth++;
13144         ndr_print_WERROR(ndr, "error_code", r->error_code);
13145         ndr_print_uint32(ndr, "site_cost", r->site_cost);
13146         ndr->depth--;
13147 }
13148
13149 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostCtr1 *r)
13150 {
13151         uint32_t cntr_info_1;
13152         if (ndr_flags & NDR_SCALARS) {
13153                 NDR_CHECK(ndr_push_align(ndr, 5));
13154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
13155                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
13156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
13157                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13158         }
13159         if (ndr_flags & NDR_BUFFERS) {
13160                 if (r->info) {
13161                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_info));
13162                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
13163                                 NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
13164                         }
13165                 }
13166         }
13167         return NDR_ERR_SUCCESS;
13168 }
13169
13170 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
13171 {
13172         uint32_t _ptr_info;
13173         uint32_t cntr_info_1;
13174         TALLOC_CTX *_mem_save_info_0;
13175         TALLOC_CTX *_mem_save_info_1;
13176         if (ndr_flags & NDR_SCALARS) {
13177                 NDR_CHECK(ndr_pull_align(ndr, 5));
13178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
13179                 if (r->num_info > 10000) {
13180                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
13181                 }
13182                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
13183                 if (_ptr_info) {
13184                         NDR_PULL_ALLOC(ndr, r->info);
13185                 } else {
13186                         r->info = NULL;
13187                 }
13188                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
13189                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13190         }
13191         if (ndr_flags & NDR_BUFFERS) {
13192                 if (r->info) {
13193                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13194                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
13195                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
13196                         NDR_PULL_ALLOC_N(ndr, r->info, ndr_get_array_size(ndr, &r->info));
13197                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
13198                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
13199                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
13200                                 NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
13201                         }
13202                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
13203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
13204                 }
13205                 if (r->info) {
13206                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info, r->num_info));
13207                 }
13208         }
13209         return NDR_ERR_SUCCESS;
13210 }
13211
13212 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostCtr1 *r)
13213 {
13214         uint32_t cntr_info_1;
13215         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostCtr1");
13216         ndr->depth++;
13217         ndr_print_uint32(ndr, "num_info", r->num_info);
13218         ndr_print_ptr(ndr, "info", r->info);
13219         ndr->depth++;
13220         if (r->info) {
13221                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->num_info);
13222                 ndr->depth++;
13223                 for (cntr_info_1=0;cntr_info_1<r->num_info;cntr_info_1++) {
13224                         char *idx_1=NULL;
13225                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
13226                                 ndr_print_drsuapi_DsSiteCostInfo(ndr, "info", &r->info[cntr_info_1]);
13227                                 free(idx_1);
13228                         }
13229                 }
13230                 ndr->depth--;
13231         }
13232         ndr->depth--;
13233         ndr_print_uint32(ndr, "unknown", r->unknown);
13234         ndr->depth--;
13235 }
13236
13237 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostCtr *r)
13238 {
13239         if (ndr_flags & NDR_SCALARS) {
13240                 int level = ndr_push_get_switch_value(ndr, r);
13241                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13242                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13243                 switch (level) {
13244                         case 1: {
13245                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
13246                         break; }
13247
13248                         default:
13249                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13250                 }
13251         }
13252         if (ndr_flags & NDR_BUFFERS) {
13253                 int level = ndr_push_get_switch_value(ndr, r);
13254                 switch (level) {
13255                         case 1:
13256                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
13257                         break;
13258
13259                         default:
13260                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13261                 }
13262         }
13263         return NDR_ERR_SUCCESS;
13264 }
13265
13266 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostCtr *r)
13267 {
13268         int level;
13269         int32_t _level;
13270         level = ndr_pull_get_switch_value(ndr, r);
13271         if (ndr_flags & NDR_SCALARS) {
13272                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13273                 if (_level != level) {
13274                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13275                 }
13276                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13277                 switch (level) {
13278                         case 1: {
13279                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
13280                         break; }
13281
13282                         default:
13283                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13284                 }
13285         }
13286         if (ndr_flags & NDR_BUFFERS) {
13287                 switch (level) {
13288                         case 1:
13289                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
13290                         break;
13291
13292                         default:
13293                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13294                 }
13295         }
13296         return NDR_ERR_SUCCESS;
13297 }
13298
13299 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostCtr *r)
13300 {
13301         int level;
13302         level = ndr_print_get_switch_value(ndr, r);
13303         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostCtr");
13304         switch (level) {
13305                 case 1:
13306                         ndr_print_drsuapi_QuerySitesByCostCtr1(ndr, "ctr1", &r->ctr1);
13307                 break;
13308
13309                 default:
13310                         ndr_print_bad_level(ndr, name, level);
13311         }
13312 }
13313
13314 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostRequest1 *r)
13315 {
13316         uint32_t cntr_site_to_1;
13317         if (ndr_flags & NDR_SCALARS) {
13318                 NDR_CHECK(ndr_push_align(ndr, 5));
13319                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
13320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
13321                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
13322                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13323                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13324         }
13325         if (ndr_flags & NDR_BUFFERS) {
13326                 if (r->site_from) {
13327                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13328                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13329                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13330                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13331                 }
13332                 if (r->site_to) {
13333                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
13334                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13335                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
13336                         }
13337                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13338                                 if (r->site_to[cntr_site_to_1]) {
13339                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13340                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13341                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13342                                         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));
13343                                 }
13344                         }
13345                 }
13346         }
13347         return NDR_ERR_SUCCESS;
13348 }
13349
13350 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
13351 {
13352         uint32_t _ptr_site_from;
13353         TALLOC_CTX *_mem_save_site_from_0;
13354         uint32_t _ptr_site_to;
13355         uint32_t cntr_site_to_1;
13356         TALLOC_CTX *_mem_save_site_to_0;
13357         TALLOC_CTX *_mem_save_site_to_1;
13358         TALLOC_CTX *_mem_save_site_to_2;
13359         if (ndr_flags & NDR_SCALARS) {
13360                 NDR_CHECK(ndr_pull_align(ndr, 5));
13361                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
13362                 if (_ptr_site_from) {
13363                         NDR_PULL_ALLOC(ndr, r->site_from);
13364                 } else {
13365                         r->site_from = NULL;
13366                 }
13367                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
13368                 if (r->num_req < 1 || r->num_req > 10000) {
13369                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
13370                 }
13371                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13372                 if (_ptr_site_to) {
13373                         NDR_PULL_ALLOC(ndr, r->site_to);
13374                 } else {
13375                         r->site_to = NULL;
13376                 }
13377                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13378                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13379         }
13380         if (ndr_flags & NDR_BUFFERS) {
13381                 if (r->site_from) {
13382                         _mem_save_site_from_0 = NDR_PULL_GET_MEM_CTX(ndr);
13383                         NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
13384                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
13385                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
13386                         if (ndr_get_array_length(ndr, &r->site_from) > ndr_get_array_size(ndr, &r->site_from)) {
13387                                 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));
13388                         }
13389                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t)));
13390                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t), CH_UTF16));
13391                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
13392                 }
13393                 if (r->site_to) {
13394                         _mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
13395                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13396                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
13397                         NDR_PULL_ALLOC_N(ndr, r->site_to, ndr_get_array_size(ndr, &r->site_to));
13398                         _mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
13399                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13400                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13401                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13402                                 if (_ptr_site_to) {
13403                                         NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
13404                                 } else {
13405                                         r->site_to[cntr_site_to_1] = NULL;
13406                                 }
13407                         }
13408                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13409                                 if (r->site_to[cntr_site_to_1]) {
13410                                         _mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
13411                                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
13412                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
13413                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
13414                                         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])) {
13415                                                 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]));
13416                                         }
13417                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t)));
13418                                         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));
13419                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
13420                                 }
13421                         }
13422                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_1, 0);
13423                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_0, 0);
13424                 }
13425                 if (r->site_to) {
13426                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->site_to, r->num_req));
13427                 }
13428         }
13429         return NDR_ERR_SUCCESS;
13430 }
13431
13432 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostRequest1 *r)
13433 {
13434         uint32_t cntr_site_to_1;
13435         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostRequest1");
13436         ndr->depth++;
13437         ndr_print_ptr(ndr, "site_from", r->site_from);
13438         ndr->depth++;
13439         if (r->site_from) {
13440                 ndr_print_string(ndr, "site_from", r->site_from);
13441         }
13442         ndr->depth--;
13443         ndr_print_uint32(ndr, "num_req", r->num_req);
13444         ndr_print_ptr(ndr, "site_to", r->site_to);
13445         ndr->depth++;
13446         if (r->site_to) {
13447                 ndr->print(ndr, "%s: ARRAY(%d)", "site_to", (int)r->num_req);
13448                 ndr->depth++;
13449                 for (cntr_site_to_1=0;cntr_site_to_1<r->num_req;cntr_site_to_1++) {
13450                         char *idx_1=NULL;
13451                         if (asprintf(&idx_1, "[%d]", cntr_site_to_1) != -1) {
13452                                 ndr_print_ptr(ndr, "site_to", r->site_to[cntr_site_to_1]);
13453                                 ndr->depth++;
13454                                 if (r->site_to[cntr_site_to_1]) {
13455                                         ndr_print_string(ndr, "site_to", r->site_to[cntr_site_to_1]);
13456                                 }
13457                                 ndr->depth--;
13458                                 free(idx_1);
13459                         }
13460                 }
13461                 ndr->depth--;
13462         }
13463         ndr->depth--;
13464         ndr_print_uint32(ndr, "flags", r->flags);
13465         ndr->depth--;
13466 }
13467
13468 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostRequest *r)
13469 {
13470         if (ndr_flags & NDR_SCALARS) {
13471                 int level = ndr_push_get_switch_value(ndr, r);
13472                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13473                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13474                 switch (level) {
13475                         case 1: {
13476                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13477                         break; }
13478
13479                         default:
13480                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13481                 }
13482         }
13483         if (ndr_flags & NDR_BUFFERS) {
13484                 int level = ndr_push_get_switch_value(ndr, r);
13485                 switch (level) {
13486                         case 1:
13487                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13488                         break;
13489
13490                         default:
13491                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13492                 }
13493         }
13494         return NDR_ERR_SUCCESS;
13495 }
13496
13497 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostRequest *r)
13498 {
13499         int level;
13500         int32_t _level;
13501         level = ndr_pull_get_switch_value(ndr, r);
13502         if (ndr_flags & NDR_SCALARS) {
13503                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13504                 if (_level != level) {
13505                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13506                 }
13507                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13508                 switch (level) {
13509                         case 1: {
13510                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13511                         break; }
13512
13513                         default:
13514                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13515                 }
13516         }
13517         if (ndr_flags & NDR_BUFFERS) {
13518                 switch (level) {
13519                         case 1:
13520                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13521                         break;
13522
13523                         default:
13524                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13525                 }
13526         }
13527         return NDR_ERR_SUCCESS;
13528 }
13529
13530 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostRequest *r)
13531 {
13532         int level;
13533         level = ndr_print_get_switch_value(ndr, r);
13534         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostRequest");
13535         switch (level) {
13536                 case 1:
13537                         ndr_print_drsuapi_QuerySitesByCostRequest1(ndr, "req1", &r->req1);
13538                 break;
13539
13540                 default:
13541                         ndr_print_bad_level(ndr, name, level);
13542         }
13543 }
13544
13545 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsBind(struct ndr_push *ndr, int flags, const struct drsuapi_DsBind *r)
13546 {
13547         if (flags & NDR_IN) {
13548                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_guid));
13549                 if (r->in.bind_guid) {
13550                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13551                 }
13552                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_info));
13553                 if (r->in.bind_info) {
13554                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13555                 }
13556         }
13557         if (flags & NDR_OUT) {
13558                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.bind_info));
13559                 if (r->out.bind_info) {
13560                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13561                 }
13562                 if (r->out.bind_handle == NULL) {
13563                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13564                 }
13565                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13566                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13567         }
13568         return NDR_ERR_SUCCESS;
13569 }
13570
13571 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsBind(struct ndr_pull *ndr, int flags, struct drsuapi_DsBind *r)
13572 {
13573         uint32_t _ptr_bind_guid;
13574         uint32_t _ptr_bind_info;
13575         TALLOC_CTX *_mem_save_bind_guid_0;
13576         TALLOC_CTX *_mem_save_bind_info_0;
13577         TALLOC_CTX *_mem_save_bind_handle_0;
13578         if (flags & NDR_IN) {
13579                 ZERO_STRUCT(r->out);
13580
13581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_guid));
13582                 if (_ptr_bind_guid) {
13583                         NDR_PULL_ALLOC(ndr, r->in.bind_guid);
13584                 } else {
13585                         r->in.bind_guid = NULL;
13586                 }
13587                 if (r->in.bind_guid) {
13588                         _mem_save_bind_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
13589                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_guid, 0);
13590                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_guid_0, 0);
13592                 }
13593                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13594                 if (_ptr_bind_info) {
13595                         NDR_PULL_ALLOC(ndr, r->in.bind_info);
13596                 } else {
13597                         r->in.bind_info = NULL;
13598                 }
13599                 if (r->in.bind_info) {
13600                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13601                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_info, 0);
13602                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13603                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13604                 }
13605                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13606                 ZERO_STRUCTP(r->out.bind_handle);
13607         }
13608         if (flags & NDR_OUT) {
13609                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13610                 if (_ptr_bind_info) {
13611                         NDR_PULL_ALLOC(ndr, r->out.bind_info);
13612                 } else {
13613                         r->out.bind_info = NULL;
13614                 }
13615                 if (r->out.bind_info) {
13616                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13617                         NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_info, 0);
13618                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13619                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13620                 }
13621                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13622                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13623                 }
13624                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13625                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13626                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13627                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13628                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13629         }
13630         return NDR_ERR_SUCCESS;
13631 }
13632
13633 _PUBLIC_ void ndr_print_drsuapi_DsBind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsBind *r)
13634 {
13635         ndr_print_struct(ndr, name, "drsuapi_DsBind");
13636         ndr->depth++;
13637         if (flags & NDR_SET_VALUES) {
13638                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13639         }
13640         if (flags & NDR_IN) {
13641                 ndr_print_struct(ndr, "in", "drsuapi_DsBind");
13642                 ndr->depth++;
13643                 ndr_print_ptr(ndr, "bind_guid", r->in.bind_guid);
13644                 ndr->depth++;
13645                 if (r->in.bind_guid) {
13646                         ndr_print_GUID(ndr, "bind_guid", r->in.bind_guid);
13647                 }
13648                 ndr->depth--;
13649                 ndr_print_ptr(ndr, "bind_info", r->in.bind_info);
13650                 ndr->depth++;
13651                 if (r->in.bind_info) {
13652                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->in.bind_info);
13653                 }
13654                 ndr->depth--;
13655                 ndr->depth--;
13656         }
13657         if (flags & NDR_OUT) {
13658                 ndr_print_struct(ndr, "out", "drsuapi_DsBind");
13659                 ndr->depth++;
13660                 ndr_print_ptr(ndr, "bind_info", r->out.bind_info);
13661                 ndr->depth++;
13662                 if (r->out.bind_info) {
13663                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->out.bind_info);
13664                 }
13665                 ndr->depth--;
13666                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13667                 ndr->depth++;
13668                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13669                 ndr->depth--;
13670                 ndr_print_WERROR(ndr, "result", r->out.result);
13671                 ndr->depth--;
13672         }
13673         ndr->depth--;
13674 }
13675
13676 static enum ndr_err_code ndr_push_drsuapi_DsUnbind(struct ndr_push *ndr, int flags, const struct drsuapi_DsUnbind *r)
13677 {
13678         if (flags & NDR_IN) {
13679                 if (r->in.bind_handle == NULL) {
13680                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13681                 }
13682                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13683         }
13684         if (flags & NDR_OUT) {
13685                 if (r->out.bind_handle == NULL) {
13686                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13687                 }
13688                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13689                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13690         }
13691         return NDR_ERR_SUCCESS;
13692 }
13693
13694 static enum ndr_err_code ndr_pull_drsuapi_DsUnbind(struct ndr_pull *ndr, int flags, struct drsuapi_DsUnbind *r)
13695 {
13696         TALLOC_CTX *_mem_save_bind_handle_0;
13697         if (flags & NDR_IN) {
13698                 ZERO_STRUCT(r->out);
13699
13700                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13701                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13702                 }
13703                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13704                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13705                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13706                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13707                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13708                 *r->out.bind_handle = *r->in.bind_handle;
13709         }
13710         if (flags & NDR_OUT) {
13711                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13712                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13713                 }
13714                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13715                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13716                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13717                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13718                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13719         }
13720         return NDR_ERR_SUCCESS;
13721 }
13722
13723 _PUBLIC_ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsUnbind *r)
13724 {
13725         ndr_print_struct(ndr, name, "drsuapi_DsUnbind");
13726         ndr->depth++;
13727         if (flags & NDR_SET_VALUES) {
13728                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13729         }
13730         if (flags & NDR_IN) {
13731                 ndr_print_struct(ndr, "in", "drsuapi_DsUnbind");
13732                 ndr->depth++;
13733                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13734                 ndr->depth++;
13735                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13736                 ndr->depth--;
13737                 ndr->depth--;
13738         }
13739         if (flags & NDR_OUT) {
13740                 ndr_print_struct(ndr, "out", "drsuapi_DsUnbind");
13741                 ndr->depth++;
13742                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13743                 ndr->depth++;
13744                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13745                 ndr->depth--;
13746                 ndr_print_WERROR(ndr, "result", r->out.result);
13747                 ndr->depth--;
13748         }
13749         ndr->depth--;
13750 }
13751
13752 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSync(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaSync *r)
13753 {
13754         if (flags & NDR_IN) {
13755                 if (r->in.bind_handle == NULL) {
13756                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13757                 }
13758                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13759                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13760                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13761                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13762         }
13763         if (flags & NDR_OUT) {
13764                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13765         }
13766         return NDR_ERR_SUCCESS;
13767 }
13768
13769 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSync(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaSync *r)
13770 {
13771         TALLOC_CTX *_mem_save_bind_handle_0;
13772         if (flags & NDR_IN) {
13773                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13774                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13775                 }
13776                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13777                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13778                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13779                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13780                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13781                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13782                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13783         }
13784         if (flags & NDR_OUT) {
13785                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13786         }
13787         return NDR_ERR_SUCCESS;
13788 }
13789
13790 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r)
13791 {
13792         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSync");
13793         ndr->depth++;
13794         if (flags & NDR_SET_VALUES) {
13795                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13796         }
13797         if (flags & NDR_IN) {
13798                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaSync");
13799                 ndr->depth++;
13800                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13801                 ndr->depth++;
13802                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13803                 ndr->depth--;
13804                 ndr_print_int32(ndr, "level", r->in.level);
13805                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13806                 ndr_print_drsuapi_DsReplicaSyncRequest(ndr, "req", &r->in.req);
13807                 ndr->depth--;
13808         }
13809         if (flags & NDR_OUT) {
13810                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaSync");
13811                 ndr->depth++;
13812                 ndr_print_WERROR(ndr, "result", r->out.result);
13813                 ndr->depth--;
13814         }
13815         ndr->depth--;
13816 }
13817
13818 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChanges(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNCChanges *r)
13819 {
13820         if (flags & NDR_IN) {
13821                 if (r->in.bind_handle == NULL) {
13822                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13823                 }
13824                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13825                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13826                 if (r->in.req == NULL) {
13827                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13828                 }
13829                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13830                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13831         }
13832         if (flags & NDR_OUT) {
13833                 if (r->out.level_out == NULL) {
13834                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13835                 }
13836                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13837                 if (r->out.ctr == NULL) {
13838                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13839                 }
13840                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13841                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13842                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13843         }
13844         return NDR_ERR_SUCCESS;
13845 }
13846
13847 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChanges(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNCChanges *r)
13848 {
13849         TALLOC_CTX *_mem_save_bind_handle_0;
13850         TALLOC_CTX *_mem_save_req_0;
13851         TALLOC_CTX *_mem_save_level_out_0;
13852         TALLOC_CTX *_mem_save_ctr_0;
13853         if (flags & NDR_IN) {
13854                 ZERO_STRUCT(r->out);
13855
13856                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13857                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13858                 }
13859                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13860                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13861                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13862                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13863                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13864                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13865                         NDR_PULL_ALLOC(ndr, r->in.req);
13866                 }
13867                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13868                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13869                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13870                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13871                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13872                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13873                 ZERO_STRUCTP(r->out.level_out);
13874                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13875                 ZERO_STRUCTP(r->out.ctr);
13876         }
13877         if (flags & NDR_OUT) {
13878                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13879                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13880                 }
13881                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13882                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13883                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13884                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13885                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13886                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13887                 }
13888                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13889                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13890                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13891                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13892                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13893                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13894         }
13895         return NDR_ERR_SUCCESS;
13896 }
13897
13898 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r)
13899 {
13900         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChanges");
13901         ndr->depth++;
13902         if (flags & NDR_SET_VALUES) {
13903                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13904         }
13905         if (flags & NDR_IN) {
13906                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNCChanges");
13907                 ndr->depth++;
13908                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13909                 ndr->depth++;
13910                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13911                 ndr->depth--;
13912                 ndr_print_int32(ndr, "level", r->in.level);
13913                 ndr_print_ptr(ndr, "req", r->in.req);
13914                 ndr->depth++;
13915                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13916                 ndr_print_drsuapi_DsGetNCChangesRequest(ndr, "req", r->in.req);
13917                 ndr->depth--;
13918                 ndr->depth--;
13919         }
13920         if (flags & NDR_OUT) {
13921                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNCChanges");
13922                 ndr->depth++;
13923                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13924                 ndr->depth++;
13925                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13926                 ndr->depth--;
13927                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13928                 ndr->depth++;
13929                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13930                 ndr_print_drsuapi_DsGetNCChangesCtr(ndr, "ctr", r->out.ctr);
13931                 ndr->depth--;
13932                 ndr_print_WERROR(ndr, "result", r->out.result);
13933                 ndr->depth--;
13934         }
13935         ndr->depth--;
13936 }
13937
13938 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefs(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13939 {
13940         if (flags & NDR_IN) {
13941                 if (r->in.bind_handle == NULL) {
13942                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13943                 }
13944                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13945                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13946                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13947                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13948         }
13949         if (flags & NDR_OUT) {
13950                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13951         }
13952         return NDR_ERR_SUCCESS;
13953 }
13954
13955 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefs(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaUpdateRefs *r)
13956 {
13957         TALLOC_CTX *_mem_save_bind_handle_0;
13958         if (flags & NDR_IN) {
13959                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13960                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13961                 }
13962                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13963                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13964                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13965                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13966                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13967                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13968                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13969         }
13970         if (flags & NDR_OUT) {
13971                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13972         }
13973         return NDR_ERR_SUCCESS;
13974 }
13975
13976 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13977 {
13978         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefs");
13979         ndr->depth++;
13980         if (flags & NDR_SET_VALUES) {
13981                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13982         }
13983         if (flags & NDR_IN) {
13984                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaUpdateRefs");
13985                 ndr->depth++;
13986                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13987                 ndr->depth++;
13988                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13989                 ndr->depth--;
13990                 ndr_print_int32(ndr, "level", r->in.level);
13991                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13992                 ndr_print_drsuapi_DsReplicaUpdateRefsRequest(ndr, "req", &r->in.req);
13993                 ndr->depth--;
13994         }
13995         if (flags & NDR_OUT) {
13996                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaUpdateRefs");
13997                 ndr->depth++;
13998                 ndr_print_WERROR(ndr, "result", r->out.result);
13999                 ndr->depth--;
14000         }
14001         ndr->depth--;
14002 }
14003
14004 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAdd(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaAdd *r)
14005 {
14006         if (flags & NDR_IN) {
14007                 if (r->in.bind_handle == NULL) {
14008                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14009                 }
14010                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14011                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14012                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
14013                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14014         }
14015         if (flags & NDR_OUT) {
14016                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14017         }
14018         return NDR_ERR_SUCCESS;
14019 }
14020
14021 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAdd(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaAdd *r)
14022 {
14023         TALLOC_CTX *_mem_save_bind_handle_0;
14024         if (flags & NDR_IN) {
14025                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14026                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14027                 }
14028                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14029                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14030                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14031                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14032                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14033                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
14034                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14035         }
14036         if (flags & NDR_OUT) {
14037                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14038         }
14039         return NDR_ERR_SUCCESS;
14040 }
14041
14042 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r)
14043 {
14044         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAdd");
14045         ndr->depth++;
14046         if (flags & NDR_SET_VALUES) {
14047                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14048         }
14049         if (flags & NDR_IN) {
14050                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaAdd");
14051                 ndr->depth++;
14052                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14053                 ndr->depth++;
14054                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14055                 ndr->depth--;
14056                 ndr_print_int32(ndr, "level", r->in.level);
14057                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
14058                 ndr_print_drsuapi_DsReplicaAddRequest(ndr, "req", &r->in.req);
14059                 ndr->depth--;
14060         }
14061         if (flags & NDR_OUT) {
14062                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaAdd");
14063                 ndr->depth++;
14064                 ndr_print_WERROR(ndr, "result", r->out.result);
14065                 ndr->depth--;
14066         }
14067         ndr->depth--;
14068 }
14069
14070 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDel(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaDel *r)
14071 {
14072         if (flags & NDR_IN) {
14073                 if (r->in.bind_handle == NULL) {
14074                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14075                 }
14076                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14077                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14078                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
14079                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14080         }
14081         if (flags & NDR_OUT) {
14082                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14083         }
14084         return NDR_ERR_SUCCESS;
14085 }
14086
14087 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDel(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaDel *r)
14088 {
14089         TALLOC_CTX *_mem_save_bind_handle_0;
14090         if (flags & NDR_IN) {
14091                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14092                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14093                 }
14094                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14095                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14096                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14097                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14098                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14099                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
14100                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14101         }
14102         if (flags & NDR_OUT) {
14103                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14104         }
14105         return NDR_ERR_SUCCESS;
14106 }
14107
14108 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r)
14109 {
14110         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDel");
14111         ndr->depth++;
14112         if (flags & NDR_SET_VALUES) {
14113                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14114         }
14115         if (flags & NDR_IN) {
14116                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaDel");
14117                 ndr->depth++;
14118                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14119                 ndr->depth++;
14120                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14121                 ndr->depth--;
14122                 ndr_print_int32(ndr, "level", r->in.level);
14123                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
14124                 ndr_print_drsuapi_DsReplicaDelRequest(ndr, "req", &r->in.req);
14125                 ndr->depth--;
14126         }
14127         if (flags & NDR_OUT) {
14128                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaDel");
14129                 ndr->depth++;
14130                 ndr_print_WERROR(ndr, "result", r->out.result);
14131                 ndr->depth--;
14132         }
14133         ndr->depth--;
14134 }
14135
14136 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMod(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaMod *r)
14137 {
14138         if (flags & NDR_IN) {
14139                 if (r->in.bind_handle == NULL) {
14140                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14141                 }
14142                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14143                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14144                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
14145                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14146         }
14147         if (flags & NDR_OUT) {
14148                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14149         }
14150         return NDR_ERR_SUCCESS;
14151 }
14152
14153 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMod(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaMod *r)
14154 {
14155         TALLOC_CTX *_mem_save_bind_handle_0;
14156         if (flags & NDR_IN) {
14157                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14158                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14159                 }
14160                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14161                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14162                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14163                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14164                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14165                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
14166                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14167         }
14168         if (flags & NDR_OUT) {
14169                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14170         }
14171         return NDR_ERR_SUCCESS;
14172 }
14173
14174 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r)
14175 {
14176         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMod");
14177         ndr->depth++;
14178         if (flags & NDR_SET_VALUES) {
14179                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14180         }
14181         if (flags & NDR_IN) {
14182                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaMod");
14183                 ndr->depth++;
14184                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14185                 ndr->depth++;
14186                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14187                 ndr->depth--;
14188                 ndr_print_int32(ndr, "level", r->in.level);
14189                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
14190                 ndr_print_drsuapi_DsReplicaModRequest(ndr, "req", &r->in.req);
14191                 ndr->depth--;
14192         }
14193         if (flags & NDR_OUT) {
14194                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaMod");
14195                 ndr->depth++;
14196                 ndr_print_WERROR(ndr, "result", r->out.result);
14197                 ndr->depth--;
14198         }
14199         ndr->depth--;
14200 }
14201
14202 static enum ndr_err_code ndr_push_DRSUAPI_VERIFY_NAMES(struct ndr_push *ndr, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
14203 {
14204         if (flags & NDR_IN) {
14205         }
14206         if (flags & NDR_OUT) {
14207                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14208         }
14209         return NDR_ERR_SUCCESS;
14210 }
14211
14212 static enum ndr_err_code ndr_pull_DRSUAPI_VERIFY_NAMES(struct ndr_pull *ndr, int flags, struct DRSUAPI_VERIFY_NAMES *r)
14213 {
14214         if (flags & NDR_IN) {
14215         }
14216         if (flags & NDR_OUT) {
14217                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14218         }
14219         return NDR_ERR_SUCCESS;
14220 }
14221
14222 _PUBLIC_ void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
14223 {
14224         ndr_print_struct(ndr, name, "DRSUAPI_VERIFY_NAMES");
14225         ndr->depth++;
14226         if (flags & NDR_SET_VALUES) {
14227                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14228         }
14229         if (flags & NDR_IN) {
14230                 ndr_print_struct(ndr, "in", "DRSUAPI_VERIFY_NAMES");
14231                 ndr->depth++;
14232                 ndr->depth--;
14233         }
14234         if (flags & NDR_OUT) {
14235                 ndr_print_struct(ndr, "out", "DRSUAPI_VERIFY_NAMES");
14236                 ndr->depth++;
14237                 ndr_print_WERROR(ndr, "result", r->out.result);
14238                 ndr->depth--;
14239         }
14240         ndr->depth--;
14241 }
14242
14243 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships *r)
14244 {
14245         if (flags & NDR_IN) {
14246                 if (r->in.bind_handle == NULL) {
14247                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14248                 }
14249                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14250                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14251                 if (r->in.req == NULL) {
14252                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14253                 }
14254                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14255                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14256         }
14257         if (flags & NDR_OUT) {
14258                 if (r->out.level_out == NULL) {
14259                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14260                 }
14261                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14262                 if (r->out.ctr == NULL) {
14263                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14264                 }
14265                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14266                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14267                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14268         }
14269         return NDR_ERR_SUCCESS;
14270 }
14271
14272 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships *r)
14273 {
14274         TALLOC_CTX *_mem_save_bind_handle_0;
14275         TALLOC_CTX *_mem_save_req_0;
14276         TALLOC_CTX *_mem_save_level_out_0;
14277         TALLOC_CTX *_mem_save_ctr_0;
14278         if (flags & NDR_IN) {
14279                 ZERO_STRUCT(r->out);
14280
14281                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14282                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14283                 }
14284                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14285                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14286                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14287                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14288                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14289                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14290                         NDR_PULL_ALLOC(ndr, r->in.req);
14291                 }
14292                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14293                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14294                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14295                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14296                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14297                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14298                 ZERO_STRUCTP(r->out.level_out);
14299                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14300                 ZERO_STRUCTP(r->out.ctr);
14301         }
14302         if (flags & NDR_OUT) {
14303                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14304                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14305                 }
14306                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14307                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14308                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14309                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14310                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14311                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14312                 }
14313                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14314                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14315                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14316                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14317                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14318                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14319         }
14320         return NDR_ERR_SUCCESS;
14321 }
14322
14323 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r)
14324 {
14325         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships");
14326         ndr->depth++;
14327         if (flags & NDR_SET_VALUES) {
14328                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14329         }
14330         if (flags & NDR_IN) {
14331                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships");
14332                 ndr->depth++;
14333                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14334                 ndr->depth++;
14335                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14336                 ndr->depth--;
14337                 ndr_print_int32(ndr, "level", r->in.level);
14338                 ndr_print_ptr(ndr, "req", r->in.req);
14339                 ndr->depth++;
14340                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14341                 ndr_print_drsuapi_DsGetMembershipsRequest(ndr, "req", r->in.req);
14342                 ndr->depth--;
14343                 ndr->depth--;
14344         }
14345         if (flags & NDR_OUT) {
14346                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships");
14347                 ndr->depth++;
14348                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14349                 ndr->depth++;
14350                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14351                 ndr->depth--;
14352                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14353                 ndr->depth++;
14354                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14355                 ndr_print_drsuapi_DsGetMembershipsCtr(ndr, "ctr", r->out.ctr);
14356                 ndr->depth--;
14357                 ndr_print_WERROR(ndr, "result", r->out.result);
14358                 ndr->depth--;
14359         }
14360         ndr->depth--;
14361 }
14362
14363 static enum ndr_err_code ndr_push_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_push *ndr, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14364 {
14365         if (flags & NDR_IN) {
14366         }
14367         if (flags & NDR_OUT) {
14368                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14369         }
14370         return NDR_ERR_SUCCESS;
14371 }
14372
14373 static enum ndr_err_code ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_pull *ndr, int flags, struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14374 {
14375         if (flags & NDR_IN) {
14376         }
14377         if (flags & NDR_OUT) {
14378                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14379         }
14380         return NDR_ERR_SUCCESS;
14381 }
14382
14383 _PUBLIC_ void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14384 {
14385         ndr_print_struct(ndr, name, "DRSUAPI_INTER_DOMAIN_MOVE");
14386         ndr->depth++;
14387         if (flags & NDR_SET_VALUES) {
14388                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14389         }
14390         if (flags & NDR_IN) {
14391                 ndr_print_struct(ndr, "in", "DRSUAPI_INTER_DOMAIN_MOVE");
14392                 ndr->depth++;
14393                 ndr->depth--;
14394         }
14395         if (flags & NDR_OUT) {
14396                 ndr_print_struct(ndr, "out", "DRSUAPI_INTER_DOMAIN_MOVE");
14397                 ndr->depth++;
14398                 ndr_print_WERROR(ndr, "result", r->out.result);
14399                 ndr->depth--;
14400         }
14401         ndr->depth--;
14402 }
14403
14404 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLog(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14405 {
14406         if (flags & NDR_IN) {
14407                 if (r->in.bind_handle == NULL) {
14408                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14409                 }
14410                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14412                 if (r->in.req == NULL) {
14413                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14414                 }
14415                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14416                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14417         }
14418         if (flags & NDR_OUT) {
14419                 if (r->out.level_out == NULL) {
14420                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14421                 }
14422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14423                 if (r->out.info == NULL) {
14424                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14425                 }
14426                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.level_out));
14427                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14428                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14429         }
14430         return NDR_ERR_SUCCESS;
14431 }
14432
14433 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLog(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNT4ChangeLog *r)
14434 {
14435         TALLOC_CTX *_mem_save_bind_handle_0;
14436         TALLOC_CTX *_mem_save_req_0;
14437         TALLOC_CTX *_mem_save_level_out_0;
14438         TALLOC_CTX *_mem_save_info_0;
14439         if (flags & NDR_IN) {
14440                 ZERO_STRUCT(r->out);
14441
14442                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14443                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14444                 }
14445                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14446                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14447                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14448                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14450                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14451                         NDR_PULL_ALLOC(ndr, r->in.req);
14452                 }
14453                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14454                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14455                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14456                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14457                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14458                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14459                 ZERO_STRUCTP(r->out.level_out);
14460                 NDR_PULL_ALLOC(ndr, r->out.info);
14461                 ZERO_STRUCTP(r->out.info);
14462         }
14463         if (flags & NDR_OUT) {
14464                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14465                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14466                 }
14467                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14468                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14469                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14470                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14471                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14472                         NDR_PULL_ALLOC(ndr, r->out.info);
14473                 }
14474                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14475                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14476                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.level_out));
14477                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14478                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14479                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14480         }
14481         return NDR_ERR_SUCCESS;
14482 }
14483
14484 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLog(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14485 {
14486         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLog");
14487         ndr->depth++;
14488         if (flags & NDR_SET_VALUES) {
14489                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14490         }
14491         if (flags & NDR_IN) {
14492                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNT4ChangeLog");
14493                 ndr->depth++;
14494                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14495                 ndr->depth++;
14496                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14497                 ndr->depth--;
14498                 ndr_print_uint32(ndr, "level", r->in.level);
14499                 ndr_print_ptr(ndr, "req", r->in.req);
14500                 ndr->depth++;
14501                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14502                 ndr_print_drsuapi_DsGetNT4ChangeLogRequest(ndr, "req", r->in.req);
14503                 ndr->depth--;
14504                 ndr->depth--;
14505         }
14506         if (flags & NDR_OUT) {
14507                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNT4ChangeLog");
14508                 ndr->depth++;
14509                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14510                 ndr->depth++;
14511                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14512                 ndr->depth--;
14513                 ndr_print_ptr(ndr, "info", r->out.info);
14514                 ndr->depth++;
14515                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.level_out);
14516                 ndr_print_drsuapi_DsGetNT4ChangeLogInfo(ndr, "info", r->out.info);
14517                 ndr->depth--;
14518                 ndr_print_WERROR(ndr, "result", r->out.result);
14519                 ndr->depth--;
14520         }
14521         ndr->depth--;
14522 }
14523
14524 static enum ndr_err_code ndr_push_drsuapi_DsCrackNames(struct ndr_push *ndr, int flags, const struct drsuapi_DsCrackNames *r)
14525 {
14526         if (flags & NDR_IN) {
14527                 if (r->in.bind_handle == NULL) {
14528                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14529                 }
14530                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14531                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14532                 if (r->in.req == NULL) {
14533                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14534                 }
14535                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14536                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14537         }
14538         if (flags & NDR_OUT) {
14539                 if (r->out.level_out == NULL) {
14540                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14541                 }
14542                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14543                 if (r->out.ctr == NULL) {
14544                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14545                 }
14546                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14547                 NDR_CHECK(ndr_push_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14548                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14549         }
14550         return NDR_ERR_SUCCESS;
14551 }
14552
14553 static enum ndr_err_code ndr_pull_drsuapi_DsCrackNames(struct ndr_pull *ndr, int flags, struct drsuapi_DsCrackNames *r)
14554 {
14555         TALLOC_CTX *_mem_save_bind_handle_0;
14556         TALLOC_CTX *_mem_save_req_0;
14557         TALLOC_CTX *_mem_save_level_out_0;
14558         TALLOC_CTX *_mem_save_ctr_0;
14559         if (flags & NDR_IN) {
14560                 ZERO_STRUCT(r->out);
14561
14562                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14563                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14564                 }
14565                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14566                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14567                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14568                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14569                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14570                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14571                         NDR_PULL_ALLOC(ndr, r->in.req);
14572                 }
14573                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14574                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14575                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14576                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14577                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14578                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14579                 ZERO_STRUCTP(r->out.level_out);
14580                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14581                 ZERO_STRUCTP(r->out.ctr);
14582         }
14583         if (flags & NDR_OUT) {
14584                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14585                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14586                 }
14587                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14588                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14589                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14590                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14591                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14592                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14593                 }
14594                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14595                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14596                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14597                 NDR_CHECK(ndr_pull_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14598                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14599                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14600         }
14601         return NDR_ERR_SUCCESS;
14602 }
14603
14604 _PUBLIC_ void ndr_print_drsuapi_DsCrackNames(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsCrackNames *r)
14605 {
14606         ndr_print_struct(ndr, name, "drsuapi_DsCrackNames");
14607         ndr->depth++;
14608         if (flags & NDR_SET_VALUES) {
14609                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14610         }
14611         if (flags & NDR_IN) {
14612                 ndr_print_struct(ndr, "in", "drsuapi_DsCrackNames");
14613                 ndr->depth++;
14614                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14615                 ndr->depth++;
14616                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14617                 ndr->depth--;
14618                 ndr_print_int32(ndr, "level", r->in.level);
14619                 ndr_print_ptr(ndr, "req", r->in.req);
14620                 ndr->depth++;
14621                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14622                 ndr_print_drsuapi_DsNameRequest(ndr, "req", r->in.req);
14623                 ndr->depth--;
14624                 ndr->depth--;
14625         }
14626         if (flags & NDR_OUT) {
14627                 ndr_print_struct(ndr, "out", "drsuapi_DsCrackNames");
14628                 ndr->depth++;
14629                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14630                 ndr->depth++;
14631                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14632                 ndr->depth--;
14633                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14634                 ndr->depth++;
14635                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14636                 ndr_print_drsuapi_DsNameCtr(ndr, "ctr", r->out.ctr);
14637                 ndr->depth--;
14638                 ndr_print_WERROR(ndr, "result", r->out.result);
14639                 ndr->depth--;
14640         }
14641         ndr->depth--;
14642 }
14643
14644 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpn(struct ndr_push *ndr, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14645 {
14646         if (flags & NDR_IN) {
14647                 if (r->in.bind_handle == NULL) {
14648                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14649                 }
14650                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14651                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14652                 if (r->in.req == NULL) {
14653                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14654                 }
14655                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14656                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14657         }
14658         if (flags & NDR_OUT) {
14659                 if (r->out.level_out == NULL) {
14660                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14661                 }
14662                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14663                 if (r->out.res == NULL) {
14664                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14665                 }
14666                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14667                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14668                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14669         }
14670         return NDR_ERR_SUCCESS;
14671 }
14672
14673 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpn(struct ndr_pull *ndr, int flags, struct drsuapi_DsWriteAccountSpn *r)
14674 {
14675         TALLOC_CTX *_mem_save_bind_handle_0;
14676         TALLOC_CTX *_mem_save_req_0;
14677         TALLOC_CTX *_mem_save_level_out_0;
14678         TALLOC_CTX *_mem_save_res_0;
14679         if (flags & NDR_IN) {
14680                 ZERO_STRUCT(r->out);
14681
14682                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14683                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14684                 }
14685                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14686                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14687                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14688                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14689                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14690                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14691                         NDR_PULL_ALLOC(ndr, r->in.req);
14692                 }
14693                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14694                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14695                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14696                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14697                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14698                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14699                 ZERO_STRUCTP(r->out.level_out);
14700                 NDR_PULL_ALLOC(ndr, r->out.res);
14701                 ZERO_STRUCTP(r->out.res);
14702         }
14703         if (flags & NDR_OUT) {
14704                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14705                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14706                 }
14707                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14708                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14709                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14710                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14711                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14712                         NDR_PULL_ALLOC(ndr, r->out.res);
14713                 }
14714                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14715                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14716                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14717                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14718                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14719                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14720         }
14721         return NDR_ERR_SUCCESS;
14722 }
14723
14724 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpn(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14725 {
14726         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpn");
14727         ndr->depth++;
14728         if (flags & NDR_SET_VALUES) {
14729                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14730         }
14731         if (flags & NDR_IN) {
14732                 ndr_print_struct(ndr, "in", "drsuapi_DsWriteAccountSpn");
14733                 ndr->depth++;
14734                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14735                 ndr->depth++;
14736                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14737                 ndr->depth--;
14738                 ndr_print_int32(ndr, "level", r->in.level);
14739                 ndr_print_ptr(ndr, "req", r->in.req);
14740                 ndr->depth++;
14741                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14742                 ndr_print_drsuapi_DsWriteAccountSpnRequest(ndr, "req", r->in.req);
14743                 ndr->depth--;
14744                 ndr->depth--;
14745         }
14746         if (flags & NDR_OUT) {
14747                 ndr_print_struct(ndr, "out", "drsuapi_DsWriteAccountSpn");
14748                 ndr->depth++;
14749                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14750                 ndr->depth++;
14751                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14752                 ndr->depth--;
14753                 ndr_print_ptr(ndr, "res", r->out.res);
14754                 ndr->depth++;
14755                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14756                 ndr_print_drsuapi_DsWriteAccountSpnResult(ndr, "res", r->out.res);
14757                 ndr->depth--;
14758                 ndr_print_WERROR(ndr, "result", r->out.result);
14759                 ndr->depth--;
14760         }
14761         ndr->depth--;
14762 }
14763
14764 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServer(struct ndr_push *ndr, int flags, const struct drsuapi_DsRemoveDSServer *r)
14765 {
14766         if (flags & NDR_IN) {
14767                 if (r->in.bind_handle == NULL) {
14768                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14769                 }
14770                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14771                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14772                 if (r->in.req == NULL) {
14773                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14774                 }
14775                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14776                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14777         }
14778         if (flags & NDR_OUT) {
14779                 if (r->out.level_out == NULL) {
14780                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14781                 }
14782                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14783                 if (r->out.res == NULL) {
14784                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14785                 }
14786                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14787                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14788                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14789         }
14790         return NDR_ERR_SUCCESS;
14791 }
14792
14793 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServer(struct ndr_pull *ndr, int flags, struct drsuapi_DsRemoveDSServer *r)
14794 {
14795         TALLOC_CTX *_mem_save_bind_handle_0;
14796         TALLOC_CTX *_mem_save_req_0;
14797         TALLOC_CTX *_mem_save_level_out_0;
14798         TALLOC_CTX *_mem_save_res_0;
14799         if (flags & NDR_IN) {
14800                 ZERO_STRUCT(r->out);
14801
14802                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14803                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14804                 }
14805                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14806                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14807                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14808                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14809                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14810                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14811                         NDR_PULL_ALLOC(ndr, r->in.req);
14812                 }
14813                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14814                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14815                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14816                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14817                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14818                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14819                 ZERO_STRUCTP(r->out.level_out);
14820                 NDR_PULL_ALLOC(ndr, r->out.res);
14821                 ZERO_STRUCTP(r->out.res);
14822         }
14823         if (flags & NDR_OUT) {
14824                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14825                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14826                 }
14827                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14828                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14829                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14830                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14831                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14832                         NDR_PULL_ALLOC(ndr, r->out.res);
14833                 }
14834                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14835                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14836                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14837                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14838                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14839                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14840         }
14841         return NDR_ERR_SUCCESS;
14842 }
14843
14844 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServer(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsRemoveDSServer *r)
14845 {
14846         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServer");
14847         ndr->depth++;
14848         if (flags & NDR_SET_VALUES) {
14849                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14850         }
14851         if (flags & NDR_IN) {
14852                 ndr_print_struct(ndr, "in", "drsuapi_DsRemoveDSServer");
14853                 ndr->depth++;
14854                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14855                 ndr->depth++;
14856                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14857                 ndr->depth--;
14858                 ndr_print_int32(ndr, "level", r->in.level);
14859                 ndr_print_ptr(ndr, "req", r->in.req);
14860                 ndr->depth++;
14861                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14862                 ndr_print_drsuapi_DsRemoveDSServerRequest(ndr, "req", r->in.req);
14863                 ndr->depth--;
14864                 ndr->depth--;
14865         }
14866         if (flags & NDR_OUT) {
14867                 ndr_print_struct(ndr, "out", "drsuapi_DsRemoveDSServer");
14868                 ndr->depth++;
14869                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14870                 ndr->depth++;
14871                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14872                 ndr->depth--;
14873                 ndr_print_ptr(ndr, "res", r->out.res);
14874                 ndr->depth++;
14875                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14876                 ndr_print_drsuapi_DsRemoveDSServerResult(ndr, "res", r->out.res);
14877                 ndr->depth--;
14878                 ndr_print_WERROR(ndr, "result", r->out.result);
14879                 ndr->depth--;
14880         }
14881         ndr->depth--;
14882 }
14883
14884 static enum ndr_err_code ndr_push_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_push *ndr, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14885 {
14886         if (flags & NDR_IN) {
14887         }
14888         if (flags & NDR_OUT) {
14889                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14890         }
14891         return NDR_ERR_SUCCESS;
14892 }
14893
14894 static enum ndr_err_code ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_pull *ndr, int flags, struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14895 {
14896         if (flags & NDR_IN) {
14897         }
14898         if (flags & NDR_OUT) {
14899                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14900         }
14901         return NDR_ERR_SUCCESS;
14902 }
14903
14904 _PUBLIC_ void ndr_print_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14905 {
14906         ndr_print_struct(ndr, name, "DRSUAPI_REMOVE_DS_DOMAIN");
14907         ndr->depth++;
14908         if (flags & NDR_SET_VALUES) {
14909                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14910         }
14911         if (flags & NDR_IN) {
14912                 ndr_print_struct(ndr, "in", "DRSUAPI_REMOVE_DS_DOMAIN");
14913                 ndr->depth++;
14914                 ndr->depth--;
14915         }
14916         if (flags & NDR_OUT) {
14917                 ndr_print_struct(ndr, "out", "DRSUAPI_REMOVE_DS_DOMAIN");
14918                 ndr->depth++;
14919                 ndr_print_WERROR(ndr, "result", r->out.result);
14920                 ndr->depth--;
14921         }
14922         ndr->depth--;
14923 }
14924
14925 static enum ndr_err_code ndr_push_drsuapi_DsGetDomainControllerInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14926 {
14927         if (flags & NDR_IN) {
14928                 if (r->in.bind_handle == NULL) {
14929                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14930                 }
14931                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14932                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14933                 if (r->in.req == NULL) {
14934                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14935                 }
14936                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14937                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14938         }
14939         if (flags & NDR_OUT) {
14940                 if (r->out.level_out == NULL) {
14941                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14942                 }
14943                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14944                 if (r->out.ctr == NULL) {
14945                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14946                 }
14947                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14948                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14949                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14950         }
14951         return NDR_ERR_SUCCESS;
14952 }
14953
14954 static enum ndr_err_code ndr_pull_drsuapi_DsGetDomainControllerInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetDomainControllerInfo *r)
14955 {
14956         TALLOC_CTX *_mem_save_bind_handle_0;
14957         TALLOC_CTX *_mem_save_req_0;
14958         TALLOC_CTX *_mem_save_level_out_0;
14959         TALLOC_CTX *_mem_save_ctr_0;
14960         if (flags & NDR_IN) {
14961                 ZERO_STRUCT(r->out);
14962
14963                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14964                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14965                 }
14966                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14967                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14968                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14969                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14970                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14971                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14972                         NDR_PULL_ALLOC(ndr, r->in.req);
14973                 }
14974                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14975                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14976                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14977                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14978                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14979                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14980                 ZERO_STRUCTP(r->out.level_out);
14981                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14982                 ZERO_STRUCTP(r->out.ctr);
14983         }
14984         if (flags & NDR_OUT) {
14985                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14986                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14987                 }
14988                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14989                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14990                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14991                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14992                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14993                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14994                 }
14995                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14996                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14997                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14998                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14999                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15000                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15001         }
15002         return NDR_ERR_SUCCESS;
15003 }
15004
15005 _PUBLIC_ void ndr_print_drsuapi_DsGetDomainControllerInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
15006 {
15007         ndr_print_struct(ndr, name, "drsuapi_DsGetDomainControllerInfo");
15008         ndr->depth++;
15009         if (flags & NDR_SET_VALUES) {
15010                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15011         }
15012         if (flags & NDR_IN) {
15013                 ndr_print_struct(ndr, "in", "drsuapi_DsGetDomainControllerInfo");
15014                 ndr->depth++;
15015                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15016                 ndr->depth++;
15017                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15018                 ndr->depth--;
15019                 ndr_print_int32(ndr, "level", r->in.level);
15020                 ndr_print_ptr(ndr, "req", r->in.req);
15021                 ndr->depth++;
15022                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15023                 ndr_print_drsuapi_DsGetDCInfoRequest(ndr, "req", r->in.req);
15024                 ndr->depth--;
15025                 ndr->depth--;
15026         }
15027         if (flags & NDR_OUT) {
15028                 ndr_print_struct(ndr, "out", "drsuapi_DsGetDomainControllerInfo");
15029                 ndr->depth++;
15030                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15031                 ndr->depth++;
15032                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15033                 ndr->depth--;
15034                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15035                 ndr->depth++;
15036                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15037                 ndr_print_drsuapi_DsGetDCInfoCtr(ndr, "ctr", r->out.ctr);
15038                 ndr->depth--;
15039                 ndr_print_WERROR(ndr, "result", r->out.result);
15040                 ndr->depth--;
15041         }
15042         ndr->depth--;
15043 }
15044
15045 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAddEntry(struct ndr_push *ndr, int flags, const struct drsuapi_DsAddEntry *r)
15046 {
15047         if (flags & NDR_IN) {
15048                 if (r->in.bind_handle == NULL) {
15049                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15050                 }
15051                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15052                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15053                 if (r->in.req == NULL) {
15054                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15055                 }
15056                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15057                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15058         }
15059         if (flags & NDR_OUT) {
15060                 if (r->out.level_out == NULL) {
15061                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15062                 }
15063                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15064                 if (r->out.ctr == NULL) {
15065                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15066                 }
15067                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15068                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15069                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15070         }
15071         return NDR_ERR_SUCCESS;
15072 }
15073
15074 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAddEntry(struct ndr_pull *ndr, int flags, struct drsuapi_DsAddEntry *r)
15075 {
15076         TALLOC_CTX *_mem_save_bind_handle_0;
15077         TALLOC_CTX *_mem_save_req_0;
15078         TALLOC_CTX *_mem_save_level_out_0;
15079         TALLOC_CTX *_mem_save_ctr_0;
15080         if (flags & NDR_IN) {
15081                 ZERO_STRUCT(r->out);
15082
15083                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15084                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15085                 }
15086                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15087                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15088                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15089                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15090                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15091                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15092                         NDR_PULL_ALLOC(ndr, r->in.req);
15093                 }
15094                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15095                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15096                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15097                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15098                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15099                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15100                 ZERO_STRUCTP(r->out.level_out);
15101                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15102                 ZERO_STRUCTP(r->out.ctr);
15103         }
15104         if (flags & NDR_OUT) {
15105                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15106                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15107                 }
15108                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15109                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15110                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15111                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15112                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15113                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15114                 }
15115                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15116                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15117                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15118                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15119                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15120                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15121         }
15122         return NDR_ERR_SUCCESS;
15123 }
15124
15125 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsAddEntry *r)
15126 {
15127         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry");
15128         ndr->depth++;
15129         if (flags & NDR_SET_VALUES) {
15130                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15131         }
15132         if (flags & NDR_IN) {
15133                 ndr_print_struct(ndr, "in", "drsuapi_DsAddEntry");
15134                 ndr->depth++;
15135                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15136                 ndr->depth++;
15137                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15138                 ndr->depth--;
15139                 ndr_print_int32(ndr, "level", r->in.level);
15140                 ndr_print_ptr(ndr, "req", r->in.req);
15141                 ndr->depth++;
15142                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15143                 ndr_print_drsuapi_DsAddEntryRequest(ndr, "req", r->in.req);
15144                 ndr->depth--;
15145                 ndr->depth--;
15146         }
15147         if (flags & NDR_OUT) {
15148                 ndr_print_struct(ndr, "out", "drsuapi_DsAddEntry");
15149                 ndr->depth++;
15150                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15151                 ndr->depth++;
15152                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15153                 ndr->depth--;
15154                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15155                 ndr->depth++;
15156                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15157                 ndr_print_drsuapi_DsAddEntryCtr(ndr, "ctr", r->out.ctr);
15158                 ndr->depth--;
15159                 ndr_print_WERROR(ndr, "result", r->out.result);
15160                 ndr->depth--;
15161         }
15162         ndr->depth--;
15163 }
15164
15165 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC(struct ndr_push *ndr, int flags, const struct drsuapi_DsExecuteKCC *r)
15166 {
15167         if (flags & NDR_IN) {
15168                 if (r->in.bind_handle == NULL) {
15169                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15170                 }
15171                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15172                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15173                 if (r->in.req == NULL) {
15174                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15175                 }
15176                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15177                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
15178         }
15179         if (flags & NDR_OUT) {
15180                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15181         }
15182         return NDR_ERR_SUCCESS;
15183 }
15184
15185 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC(struct ndr_pull *ndr, int flags, struct drsuapi_DsExecuteKCC *r)
15186 {
15187         TALLOC_CTX *_mem_save_bind_handle_0;
15188         TALLOC_CTX *_mem_save_req_0;
15189         if (flags & NDR_IN) {
15190                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15191                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15192                 }
15193                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15194                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15195                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15196                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15197                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15198                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15199                         NDR_PULL_ALLOC(ndr, r->in.req);
15200                 }
15201                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15202                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15203                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15204                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
15205                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15206         }
15207         if (flags & NDR_OUT) {
15208                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15209         }
15210         return NDR_ERR_SUCCESS;
15211 }
15212
15213 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsExecuteKCC *r)
15214 {
15215         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC");
15216         ndr->depth++;
15217         if (flags & NDR_SET_VALUES) {
15218                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15219         }
15220         if (flags & NDR_IN) {
15221                 ndr_print_struct(ndr, "in", "drsuapi_DsExecuteKCC");
15222                 ndr->depth++;
15223                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15224                 ndr->depth++;
15225                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15226                 ndr->depth--;
15227                 ndr_print_uint32(ndr, "level", r->in.level);
15228                 ndr_print_ptr(ndr, "req", r->in.req);
15229                 ndr->depth++;
15230                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15231                 ndr_print_drsuapi_DsExecuteKCCRequest(ndr, "req", r->in.req);
15232                 ndr->depth--;
15233                 ndr->depth--;
15234         }
15235         if (flags & NDR_OUT) {
15236                 ndr_print_struct(ndr, "out", "drsuapi_DsExecuteKCC");
15237                 ndr->depth++;
15238                 ndr_print_WERROR(ndr, "result", r->out.result);
15239                 ndr->depth--;
15240         }
15241         ndr->depth--;
15242 }
15243
15244 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaGetInfo *r)
15245 {
15246         if (flags & NDR_IN) {
15247                 if (r->in.bind_handle == NULL) {
15248                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15249                 }
15250                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15251                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, r->in.level));
15252                 if (r->in.req == NULL) {
15253                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15254                 }
15255                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15256                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15257         }
15258         if (flags & NDR_OUT) {
15259                 if (r->out.info_type == NULL) {
15260                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15261                 }
15262                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, *r->out.info_type));
15263                 if (r->out.info == NULL) {
15264                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15265                 }
15266                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.info_type));
15267                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15268                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15269         }
15270         return NDR_ERR_SUCCESS;
15271 }
15272
15273 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaGetInfo *r)
15274 {
15275         TALLOC_CTX *_mem_save_bind_handle_0;
15276         TALLOC_CTX *_mem_save_req_0;
15277         TALLOC_CTX *_mem_save_info_type_0;
15278         TALLOC_CTX *_mem_save_info_0;
15279         if (flags & NDR_IN) {
15280                 ZERO_STRUCT(r->out);
15281
15282                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15283                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15284                 }
15285                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15286                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15287                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15288                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15289                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, &r->in.level));
15290                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15291                         NDR_PULL_ALLOC(ndr, r->in.req);
15292                 }
15293                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15294                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15295                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15296                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15297                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15298                 NDR_PULL_ALLOC(ndr, r->out.info_type);
15299                 ZERO_STRUCTP(r->out.info_type);
15300                 NDR_PULL_ALLOC(ndr, r->out.info);
15301                 ZERO_STRUCTP(r->out.info);
15302         }
15303         if (flags & NDR_OUT) {
15304                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15305                         NDR_PULL_ALLOC(ndr, r->out.info_type);
15306                 }
15307                 _mem_save_info_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
15308                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_type, LIBNDR_FLAG_REF_ALLOC);
15309                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->out.info_type));
15310                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_type_0, LIBNDR_FLAG_REF_ALLOC);
15311                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15312                         NDR_PULL_ALLOC(ndr, r->out.info);
15313                 }
15314                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15315                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
15316                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.info_type));
15317                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15318                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15319                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15320         }
15321         return NDR_ERR_SUCCESS;
15322 }
15323
15324 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaGetInfo *r)
15325 {
15326         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfo");
15327         ndr->depth++;
15328         if (flags & NDR_SET_VALUES) {
15329                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15330         }
15331         if (flags & NDR_IN) {
15332                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaGetInfo");
15333                 ndr->depth++;
15334                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15335                 ndr->depth++;
15336                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15337                 ndr->depth--;
15338                 ndr_print_drsuapi_DsReplicaGetInfoLevel(ndr, "level", r->in.level);
15339                 ndr_print_ptr(ndr, "req", r->in.req);
15340                 ndr->depth++;
15341                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15342                 ndr_print_drsuapi_DsReplicaGetInfoRequest(ndr, "req", r->in.req);
15343                 ndr->depth--;
15344                 ndr->depth--;
15345         }
15346         if (flags & NDR_OUT) {
15347                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaGetInfo");
15348                 ndr->depth++;
15349                 ndr_print_ptr(ndr, "info_type", r->out.info_type);
15350                 ndr->depth++;
15351                 ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", *r->out.info_type);
15352                 ndr->depth--;
15353                 ndr_print_ptr(ndr, "info", r->out.info);
15354                 ndr->depth++;
15355                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.info_type);
15356                 ndr_print_drsuapi_DsReplicaInfo(ndr, "info", r->out.info);
15357                 ndr->depth--;
15358                 ndr_print_WERROR(ndr, "result", r->out.result);
15359                 ndr->depth--;
15360         }
15361         ndr->depth--;
15362 }
15363
15364 static enum ndr_err_code ndr_push_DRSUAPI_ADD_SID_HISTORY(struct ndr_push *ndr, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15365 {
15366         if (flags & NDR_IN) {
15367         }
15368         if (flags & NDR_OUT) {
15369                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15370         }
15371         return NDR_ERR_SUCCESS;
15372 }
15373
15374 static enum ndr_err_code ndr_pull_DRSUAPI_ADD_SID_HISTORY(struct ndr_pull *ndr, int flags, struct DRSUAPI_ADD_SID_HISTORY *r)
15375 {
15376         if (flags & NDR_IN) {
15377         }
15378         if (flags & NDR_OUT) {
15379                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15380         }
15381         return NDR_ERR_SUCCESS;
15382 }
15383
15384 _PUBLIC_ void ndr_print_DRSUAPI_ADD_SID_HISTORY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15385 {
15386         ndr_print_struct(ndr, name, "DRSUAPI_ADD_SID_HISTORY");
15387         ndr->depth++;
15388         if (flags & NDR_SET_VALUES) {
15389                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15390         }
15391         if (flags & NDR_IN) {
15392                 ndr_print_struct(ndr, "in", "DRSUAPI_ADD_SID_HISTORY");
15393                 ndr->depth++;
15394                 ndr->depth--;
15395         }
15396         if (flags & NDR_OUT) {
15397                 ndr_print_struct(ndr, "out", "DRSUAPI_ADD_SID_HISTORY");
15398                 ndr->depth++;
15399                 ndr_print_WERROR(ndr, "result", r->out.result);
15400                 ndr->depth--;
15401         }
15402         ndr->depth--;
15403 }
15404
15405 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships2 *r)
15406 {
15407         if (flags & NDR_IN) {
15408                 if (r->in.bind_handle == NULL) {
15409                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15410                 }
15411                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15412                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15413                 if (r->in.req == NULL) {
15414                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15415                 }
15416                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15417                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15418         }
15419         if (flags & NDR_OUT) {
15420                 if (r->out.level_out == NULL) {
15421                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15422                 }
15423                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15424                 if (r->out.ctr == NULL) {
15425                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15426                 }
15427                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15428                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15429                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15430         }
15431         return NDR_ERR_SUCCESS;
15432 }
15433
15434 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships2 *r)
15435 {
15436         TALLOC_CTX *_mem_save_bind_handle_0;
15437         TALLOC_CTX *_mem_save_req_0;
15438         TALLOC_CTX *_mem_save_level_out_0;
15439         TALLOC_CTX *_mem_save_ctr_0;
15440         if (flags & NDR_IN) {
15441                 ZERO_STRUCT(r->out);
15442
15443                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15444                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15445                 }
15446                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15447                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15448                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15449                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15450                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15451                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15452                         NDR_PULL_ALLOC(ndr, r->in.req);
15453                 }
15454                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15455                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15456                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15457                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15458                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15459                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15460                 ZERO_STRUCTP(r->out.level_out);
15461                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15462                 ZERO_STRUCTP(r->out.ctr);
15463         }
15464         if (flags & NDR_OUT) {
15465                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15466                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15467                 }
15468                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15469                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15470                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15471                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15472                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15473                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15474                 }
15475                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15476                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15477                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15478                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15479                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15480                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15481         }
15482         return NDR_ERR_SUCCESS;
15483 }
15484
15485 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships2 *r)
15486 {
15487         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2");
15488         ndr->depth++;
15489         if (flags & NDR_SET_VALUES) {
15490                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15491         }
15492         if (flags & NDR_IN) {
15493                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships2");
15494                 ndr->depth++;
15495                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15496                 ndr->depth++;
15497                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15498                 ndr->depth--;
15499                 ndr_print_int32(ndr, "level", r->in.level);
15500                 ndr_print_ptr(ndr, "req", r->in.req);
15501                 ndr->depth++;
15502                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15503                 ndr_print_drsuapi_DsGetMemberships2Request(ndr, "req", r->in.req);
15504                 ndr->depth--;
15505                 ndr->depth--;
15506         }
15507         if (flags & NDR_OUT) {
15508                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships2");
15509                 ndr->depth++;
15510                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15511                 ndr->depth++;
15512                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15513                 ndr->depth--;
15514                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15515                 ndr->depth++;
15516                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15517                 ndr_print_drsuapi_DsGetMemberships2Ctr(ndr, "ctr", r->out.ctr);
15518                 ndr->depth--;
15519                 ndr_print_WERROR(ndr, "result", r->out.result);
15520                 ndr->depth--;
15521         }
15522         ndr->depth--;
15523 }
15524
15525 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15526 {
15527         if (flags & NDR_IN) {
15528         }
15529         if (flags & NDR_OUT) {
15530                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15531         }
15532         return NDR_ERR_SUCCESS;
15533 }
15534
15535 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15536 {
15537         if (flags & NDR_IN) {
15538         }
15539         if (flags & NDR_OUT) {
15540                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15541         }
15542         return NDR_ERR_SUCCESS;
15543 }
15544
15545 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15546 {
15547         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15548         ndr->depth++;
15549         if (flags & NDR_SET_VALUES) {
15550                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15551         }
15552         if (flags & NDR_IN) {
15553                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15554                 ndr->depth++;
15555                 ndr->depth--;
15556         }
15557         if (flags & NDR_OUT) {
15558                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15559                 ndr->depth++;
15560                 ndr_print_WERROR(ndr, "result", r->out.result);
15561                 ndr->depth--;
15562         }
15563         ndr->depth--;
15564 }
15565
15566 static enum ndr_err_code ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_push *ndr, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15567 {
15568         if (flags & NDR_IN) {
15569         }
15570         if (flags & NDR_OUT) {
15571                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15572         }
15573         return NDR_ERR_SUCCESS;
15574 }
15575
15576 static enum ndr_err_code ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_pull *ndr, int flags, struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15577 {
15578         if (flags & NDR_IN) {
15579         }
15580         if (flags & NDR_OUT) {
15581                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15582         }
15583         return NDR_ERR_SUCCESS;
15584 }
15585
15586 _PUBLIC_ void ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15587 {
15588         ndr_print_struct(ndr, name, "DRSUAPI_GET_OBJECT_EXISTENCE");
15589         ndr->depth++;
15590         if (flags & NDR_SET_VALUES) {
15591                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15592         }
15593         if (flags & NDR_IN) {
15594                 ndr_print_struct(ndr, "in", "DRSUAPI_GET_OBJECT_EXISTENCE");
15595                 ndr->depth++;
15596                 ndr->depth--;
15597         }
15598         if (flags & NDR_OUT) {
15599                 ndr_print_struct(ndr, "out", "DRSUAPI_GET_OBJECT_EXISTENCE");
15600                 ndr->depth++;
15601                 ndr_print_WERROR(ndr, "result", r->out.result);
15602                 ndr->depth--;
15603         }
15604         ndr->depth--;
15605 }
15606
15607 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCost(struct ndr_push *ndr, int flags, const struct drsuapi_QuerySitesByCost *r)
15608 {
15609         if (flags & NDR_IN) {
15610                 if (r->in.bind_handle == NULL) {
15611                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15612                 }
15613                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15614                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15615                 if (r->in.req == NULL) {
15616                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15617                 }
15618                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15619                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15620         }
15621         if (flags & NDR_OUT) {
15622                 if (r->out.level_out == NULL) {
15623                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15624                 }
15625                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15626                 if (r->out.ctr == NULL) {
15627                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15628                 }
15629                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15630                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15631                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15632         }
15633         return NDR_ERR_SUCCESS;
15634 }
15635
15636 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCost(struct ndr_pull *ndr, int flags, struct drsuapi_QuerySitesByCost *r)
15637 {
15638         TALLOC_CTX *_mem_save_bind_handle_0;
15639         TALLOC_CTX *_mem_save_req_0;
15640         TALLOC_CTX *_mem_save_level_out_0;
15641         TALLOC_CTX *_mem_save_ctr_0;
15642         if (flags & NDR_IN) {
15643                 ZERO_STRUCT(r->out);
15644
15645                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15646                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15647                 }
15648                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15649                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15650                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15651                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15652                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15653                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15654                         NDR_PULL_ALLOC(ndr, r->in.req);
15655                 }
15656                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15657                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15658                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15659                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15660                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15661                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15662                 ZERO_STRUCTP(r->out.level_out);
15663                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15664                 ZERO_STRUCTP(r->out.ctr);
15665         }
15666         if (flags & NDR_OUT) {
15667                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15668                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15669                 }
15670                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15671                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15672                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15673                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15674                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15675                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15676                 }
15677                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15678                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15679                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15680                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15681                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15682                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15683         }
15684         return NDR_ERR_SUCCESS;
15685 }
15686
15687 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCost(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_QuerySitesByCost *r)
15688 {
15689         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCost");
15690         ndr->depth++;
15691         if (flags & NDR_SET_VALUES) {
15692                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15693         }
15694         if (flags & NDR_IN) {
15695                 ndr_print_struct(ndr, "in", "drsuapi_QuerySitesByCost");
15696                 ndr->depth++;
15697                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15698                 ndr->depth++;
15699                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15700                 ndr->depth--;
15701                 ndr_print_int32(ndr, "level", r->in.level);
15702                 ndr_print_ptr(ndr, "req", r->in.req);
15703                 ndr->depth++;
15704                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15705                 ndr_print_drsuapi_QuerySitesByCostRequest(ndr, "req", r->in.req);
15706                 ndr->depth--;
15707                 ndr->depth--;
15708         }
15709         if (flags & NDR_OUT) {
15710                 ndr_print_struct(ndr, "out", "drsuapi_QuerySitesByCost");
15711                 ndr->depth++;
15712                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15713                 ndr->depth++;
15714                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15715                 ndr->depth--;
15716                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15717                 ndr->depth++;
15718                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15719                 ndr_print_drsuapi_QuerySitesByCostCtr(ndr, "ctr", r->out.ctr);
15720                 ndr->depth--;
15721                 ndr_print_WERROR(ndr, "result", r->out.result);
15722                 ndr->depth--;
15723         }
15724         ndr->depth--;
15725 }
15726
15727 static const struct ndr_interface_call drsuapi_calls[] = {
15728         {
15729                 "drsuapi_DsBind",
15730                 sizeof(struct drsuapi_DsBind),
15731                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsBind,
15732                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsBind,
15733                 (ndr_print_function_t) ndr_print_drsuapi_DsBind,
15734                 false,
15735         },
15736         {
15737                 "drsuapi_DsUnbind",
15738                 sizeof(struct drsuapi_DsUnbind),
15739                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsUnbind,
15740                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsUnbind,
15741                 (ndr_print_function_t) ndr_print_drsuapi_DsUnbind,
15742                 false,
15743         },
15744         {
15745                 "drsuapi_DsReplicaSync",
15746                 sizeof(struct drsuapi_DsReplicaSync),
15747                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaSync,
15748                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaSync,
15749                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaSync,
15750                 false,
15751         },
15752         {
15753                 "drsuapi_DsGetNCChanges",
15754                 sizeof(struct drsuapi_DsGetNCChanges),
15755                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNCChanges,
15756                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNCChanges,
15757                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNCChanges,
15758                 false,
15759         },
15760         {
15761                 "drsuapi_DsReplicaUpdateRefs",
15762                 sizeof(struct drsuapi_DsReplicaUpdateRefs),
15763                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaUpdateRefs,
15764                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaUpdateRefs,
15765                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaUpdateRefs,
15766                 false,
15767         },
15768         {
15769                 "drsuapi_DsReplicaAdd",
15770                 sizeof(struct drsuapi_DsReplicaAdd),
15771                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaAdd,
15772                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaAdd,
15773                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaAdd,
15774                 false,
15775         },
15776         {
15777                 "drsuapi_DsReplicaDel",
15778                 sizeof(struct drsuapi_DsReplicaDel),
15779                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaDel,
15780                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaDel,
15781                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaDel,
15782                 false,
15783         },
15784         {
15785                 "drsuapi_DsReplicaMod",
15786                 sizeof(struct drsuapi_DsReplicaMod),
15787                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaMod,
15788                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaMod,
15789                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaMod,
15790                 false,
15791         },
15792         {
15793                 "DRSUAPI_VERIFY_NAMES",
15794                 sizeof(struct DRSUAPI_VERIFY_NAMES),
15795                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_VERIFY_NAMES,
15796                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_VERIFY_NAMES,
15797                 (ndr_print_function_t) ndr_print_DRSUAPI_VERIFY_NAMES,
15798                 false,
15799         },
15800         {
15801                 "drsuapi_DsGetMemberships",
15802                 sizeof(struct drsuapi_DsGetMemberships),
15803                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships,
15804                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships,
15805                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships,
15806                 false,
15807         },
15808         {
15809                 "DRSUAPI_INTER_DOMAIN_MOVE",
15810                 sizeof(struct DRSUAPI_INTER_DOMAIN_MOVE),
15811                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_INTER_DOMAIN_MOVE,
15812                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE,
15813                 (ndr_print_function_t) ndr_print_DRSUAPI_INTER_DOMAIN_MOVE,
15814                 false,
15815         },
15816         {
15817                 "drsuapi_DsGetNT4ChangeLog",
15818                 sizeof(struct drsuapi_DsGetNT4ChangeLog),
15819                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNT4ChangeLog,
15820                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNT4ChangeLog,
15821                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNT4ChangeLog,
15822                 false,
15823         },
15824         {
15825                 "drsuapi_DsCrackNames",
15826                 sizeof(struct drsuapi_DsCrackNames),
15827                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsCrackNames,
15828                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsCrackNames,
15829                 (ndr_print_function_t) ndr_print_drsuapi_DsCrackNames,
15830                 false,
15831         },
15832         {
15833                 "drsuapi_DsWriteAccountSpn",
15834                 sizeof(struct drsuapi_DsWriteAccountSpn),
15835                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsWriteAccountSpn,
15836                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsWriteAccountSpn,
15837                 (ndr_print_function_t) ndr_print_drsuapi_DsWriteAccountSpn,
15838                 false,
15839         },
15840         {
15841                 "drsuapi_DsRemoveDSServer",
15842                 sizeof(struct drsuapi_DsRemoveDSServer),
15843                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsRemoveDSServer,
15844                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsRemoveDSServer,
15845                 (ndr_print_function_t) ndr_print_drsuapi_DsRemoveDSServer,
15846                 false,
15847         },
15848         {
15849                 "DRSUAPI_REMOVE_DS_DOMAIN",
15850                 sizeof(struct DRSUAPI_REMOVE_DS_DOMAIN),
15851                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REMOVE_DS_DOMAIN,
15852                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN,
15853                 (ndr_print_function_t) ndr_print_DRSUAPI_REMOVE_DS_DOMAIN,
15854                 false,
15855         },
15856         {
15857                 "drsuapi_DsGetDomainControllerInfo",
15858                 sizeof(struct drsuapi_DsGetDomainControllerInfo),
15859                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetDomainControllerInfo,
15860                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetDomainControllerInfo,
15861                 (ndr_print_function_t) ndr_print_drsuapi_DsGetDomainControllerInfo,
15862                 false,
15863         },
15864         {
15865                 "drsuapi_DsAddEntry",
15866                 sizeof(struct drsuapi_DsAddEntry),
15867                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsAddEntry,
15868                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsAddEntry,
15869                 (ndr_print_function_t) ndr_print_drsuapi_DsAddEntry,
15870                 false,
15871         },
15872         {
15873                 "drsuapi_DsExecuteKCC",
15874                 sizeof(struct drsuapi_DsExecuteKCC),
15875                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsExecuteKCC,
15876                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsExecuteKCC,
15877                 (ndr_print_function_t) ndr_print_drsuapi_DsExecuteKCC,
15878                 false,
15879         },
15880         {
15881                 "drsuapi_DsReplicaGetInfo",
15882                 sizeof(struct drsuapi_DsReplicaGetInfo),
15883                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaGetInfo,
15884                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaGetInfo,
15885                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaGetInfo,
15886                 false,
15887         },
15888         {
15889                 "DRSUAPI_ADD_SID_HISTORY",
15890                 sizeof(struct DRSUAPI_ADD_SID_HISTORY),
15891                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_ADD_SID_HISTORY,
15892                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_ADD_SID_HISTORY,
15893                 (ndr_print_function_t) ndr_print_DRSUAPI_ADD_SID_HISTORY,
15894                 false,
15895         },
15896         {
15897                 "drsuapi_DsGetMemberships2",
15898                 sizeof(struct drsuapi_DsGetMemberships2),
15899                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships2,
15900                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships2,
15901                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships2,
15902                 false,
15903         },
15904         {
15905                 "DRSUAPI_REPLICA_VERIFY_OBJECTS",
15906                 sizeof(struct DRSUAPI_REPLICA_VERIFY_OBJECTS),
15907                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15908                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15909                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15910                 false,
15911         },
15912         {
15913                 "DRSUAPI_GET_OBJECT_EXISTENCE",
15914                 sizeof(struct DRSUAPI_GET_OBJECT_EXISTENCE),
15915                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE,
15916                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE,
15917                 (ndr_print_function_t) ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE,
15918                 false,
15919         },
15920         {
15921                 "drsuapi_QuerySitesByCost",
15922                 sizeof(struct drsuapi_QuerySitesByCost),
15923                 (ndr_push_flags_fn_t) ndr_push_drsuapi_QuerySitesByCost,
15924                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_QuerySitesByCost,
15925                 (ndr_print_function_t) ndr_print_drsuapi_QuerySitesByCost,
15926                 false,
15927         },
15928         { NULL, 0, NULL, NULL, NULL, false }
15929 };
15930
15931 static const char * const drsuapi_endpoint_strings[] = {
15932         "ncacn_np:[\\pipe\\lsass]",
15933         "ncacn_np:[\\pipe\\protected_storage]",
15934         "ncacn_ip_tcp:",
15935         "ncalrpc:",
15936 };
15937
15938 static const struct ndr_interface_string_array drsuapi_endpoints = {
15939         .count  = 4,
15940         .names  = drsuapi_endpoint_strings
15941 };
15942
15943 static const char * const drsuapi_authservice_strings[] = {
15944         "ldap",
15945 };
15946
15947 static const struct ndr_interface_string_array drsuapi_authservices = {
15948         .count  = 1,
15949         .names  = drsuapi_authservice_strings
15950 };
15951
15952
15953 const struct ndr_interface_table ndr_table_drsuapi = {
15954         .name           = "drsuapi",
15955         .syntax_id      = {
15956                 {0xe3514235,0x4b06,0x11d1,{0xab,0x04},{0x00,0xc0,0x4f,0xc2,0xdc,0xd2}},
15957                 NDR_DRSUAPI_VERSION
15958         },
15959         .helpstring     = NDR_DRSUAPI_HELPSTRING,
15960         .num_calls      = 25,
15961         .calls          = drsuapi_calls,
15962         .endpoints      = &drsuapi_endpoints,
15963         .authservices   = &drsuapi_authservices
15964 };
15965