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_rDNAttId: val = "DRSUAPI_ATTRIBUTE_rDNAttId"; break;
1393                         case DRSUAPI_ATTRIBUTE_attributeID: val = "DRSUAPI_ATTRIBUTE_attributeID"; break;
1394                         case DRSUAPI_ATTRIBUTE_attributeSyntax: val = "DRSUAPI_ATTRIBUTE_attributeSyntax"; break;
1395                         case DRSUAPI_ATTRIBUTE_isSingleValued: val = "DRSUAPI_ATTRIBUTE_isSingleValued"; break;
1396                         case DRSUAPI_ATTRIBUTE_rangeLower: val = "DRSUAPI_ATTRIBUTE_rangeLower"; break;
1397                         case DRSUAPI_ATTRIBUTE_rangeUpper: val = "DRSUAPI_ATTRIBUTE_rangeUpper"; break;
1398                         case DRSUAPI_ATTRIBUTE_dMDLocation: val = "DRSUAPI_ATTRIBUTE_dMDLocation"; break;
1399                         case DRSUAPI_ATTRIBUTE_objectVersion: val = "DRSUAPI_ATTRIBUTE_objectVersion"; break;
1400                         case DRSUAPI_ATTRIBUTE_invocationId: val = "DRSUAPI_ATTRIBUTE_invocationId"; break;
1401                         case DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly: val = "DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly"; break;
1402                         case DRSUAPI_ATTRIBUTE_adminDisplayName: val = "DRSUAPI_ATTRIBUTE_adminDisplayName"; break;
1403                         case DRSUAPI_ATTRIBUTE_adminDescription: val = "DRSUAPI_ATTRIBUTE_adminDescription"; break;
1404                         case DRSUAPI_ATTRIBUTE_oMSyntax: val = "DRSUAPI_ATTRIBUTE_oMSyntax"; break;
1405                         case DRSUAPI_ATTRIBUTE_ntSecurityDescriptor: val = "DRSUAPI_ATTRIBUTE_ntSecurityDescriptor"; break;
1406                         case DRSUAPI_ATTRIBUTE_searchFlags: val = "DRSUAPI_ATTRIBUTE_searchFlags"; break;
1407                         case DRSUAPI_ATTRIBUTE_auxiliaryClass: val = "DRSUAPI_ATTRIBUTE_auxiliaryClass"; break;
1408                         case DRSUAPI_ATTRIBUTE_lDAPDisplayName: val = "DRSUAPI_ATTRIBUTE_lDAPDisplayName"; break;
1409                         case DRSUAPI_ATTRIBUTE_name: val = "DRSUAPI_ATTRIBUTE_name"; break;
1410                         case DRSUAPI_ATTRIBUTE_userAccountControl: val = "DRSUAPI_ATTRIBUTE_userAccountControl"; break;
1411                         case DRSUAPI_ATTRIBUTE_currentValue: val = "DRSUAPI_ATTRIBUTE_currentValue"; break;
1412                         case DRSUAPI_ATTRIBUTE_homeDirectory: val = "DRSUAPI_ATTRIBUTE_homeDirectory"; break;
1413                         case DRSUAPI_ATTRIBUTE_homeDrive: val = "DRSUAPI_ATTRIBUTE_homeDrive"; break;
1414                         case DRSUAPI_ATTRIBUTE_scriptPath: val = "DRSUAPI_ATTRIBUTE_scriptPath"; break;
1415                         case DRSUAPI_ATTRIBUTE_profilePath: val = "DRSUAPI_ATTRIBUTE_profilePath"; break;
1416                         case DRSUAPI_ATTRIBUTE_objectSid: val = "DRSUAPI_ATTRIBUTE_objectSid"; break;
1417                         case DRSUAPI_ATTRIBUTE_schemaIDGUID: val = "DRSUAPI_ATTRIBUTE_schemaIDGUID"; break;
1418                         case DRSUAPI_ATTRIBUTE_dBCSPwd: val = "DRSUAPI_ATTRIBUTE_dBCSPwd"; break;
1419                         case DRSUAPI_ATTRIBUTE_logonHours: val = "DRSUAPI_ATTRIBUTE_logonHours"; break;
1420                         case DRSUAPI_ATTRIBUTE_userWorkstations: val = "DRSUAPI_ATTRIBUTE_userWorkstations"; break;
1421                         case DRSUAPI_ATTRIBUTE_unicodePwd: val = "DRSUAPI_ATTRIBUTE_unicodePwd"; break;
1422                         case DRSUAPI_ATTRIBUTE_ntPwdHistory: val = "DRSUAPI_ATTRIBUTE_ntPwdHistory"; break;
1423                         case DRSUAPI_ATTRIBUTE_priorValue: val = "DRSUAPI_ATTRIBUTE_priorValue"; break;
1424                         case DRSUAPI_ATTRIBUTE_supplementalCredentials: val = "DRSUAPI_ATTRIBUTE_supplementalCredentials"; break;
1425                         case DRSUAPI_ATTRIBUTE_trustAuthIncoming: val = "DRSUAPI_ATTRIBUTE_trustAuthIncoming"; break;
1426                         case DRSUAPI_ATTRIBUTE_trustAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_trustAuthOutgoing"; break;
1427                         case DRSUAPI_ATTRIBUTE_lmPwdHistory: val = "DRSUAPI_ATTRIBUTE_lmPwdHistory"; break;
1428                         case DRSUAPI_ATTRIBUTE_systemPossSuperiors: val = "DRSUAPI_ATTRIBUTE_systemPossSuperiors"; break;
1429                         case DRSUAPI_ATTRIBUTE_systemMayContain: val = "DRSUAPI_ATTRIBUTE_systemMayContain"; break;
1430                         case DRSUAPI_ATTRIBUTE_systemMustContain: val = "DRSUAPI_ATTRIBUTE_systemMustContain"; break;
1431                         case DRSUAPI_ATTRIBUTE_systemAuxiliaryClass: val = "DRSUAPI_ATTRIBUTE_systemAuxiliaryClass"; break;
1432                         case DRSUAPI_ATTRIBUTE_sAMAccountName: val = "DRSUAPI_ATTRIBUTE_sAMAccountName"; break;
1433                         case DRSUAPI_ATTRIBUTE_sAMAccountType: val = "DRSUAPI_ATTRIBUTE_sAMAccountType"; break;
1434                         case DRSUAPI_ATTRIBUTE_fSMORoleOwner: val = "DRSUAPI_ATTRIBUTE_fSMORoleOwner"; break;
1435                         case DRSUAPI_ATTRIBUTE_systemFlags: val = "DRSUAPI_ATTRIBUTE_systemFlags"; break;
1436                         case DRSUAPI_ATTRIBUTE_serverReference: val = "DRSUAPI_ATTRIBUTE_serverReference"; break;
1437                         case DRSUAPI_ATTRIBUTE_serverReferenceBL: val = "DRSUAPI_ATTRIBUTE_serverReferenceBL"; break;
1438                         case DRSUAPI_ATTRIBUTE_initialAuthIncoming: val = "DRSUAPI_ATTRIBUTE_initialAuthIncoming"; break;
1439                         case DRSUAPI_ATTRIBUTE_initialAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_initialAuthOutgoing"; break;
1440                         case DRSUAPI_ATTRIBUTE_wellKnownObjects: val = "DRSUAPI_ATTRIBUTE_wellKnownObjects"; break;
1441                         case DRSUAPI_ATTRIBUTE_dNSHostName: val = "DRSUAPI_ATTRIBUTE_dNSHostName"; break;
1442                         case DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet: val = "DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet"; break;
1443                         case DRSUAPI_ATTRIBUTE_userPrincipalName: val = "DRSUAPI_ATTRIBUTE_userPrincipalName"; break;
1444                         case DRSUAPI_ATTRIBUTE_groupType: val = "DRSUAPI_ATTRIBUTE_groupType"; break;
1445                         case DRSUAPI_ATTRIBUTE_servicePrincipalName: val = "DRSUAPI_ATTRIBUTE_servicePrincipalName"; break;
1446                         case DRSUAPI_ATTRIBUTE_objectCategory: val = "DRSUAPI_ATTRIBUTE_objectCategory"; break;
1447                         case DRSUAPI_ATTRIBUTE_gPLink: val = "DRSUAPI_ATTRIBUTE_gPLink"; break;
1448                         case DRSUAPI_ATTRIBUTE_transportAddressAttribute: val = "DRSUAPI_ATTRIBUTE_transportAddressAttribute"; break;
1449                         case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version: val = "DRSUAPI_ATTRIBUTE_msDS_Behavior_Version"; break;
1450                         case DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber: val = "DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber"; break;
1451                         case DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs: val = "DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs"; break;
1452                         case DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs"; break;
1453                 }
1454                 ndr_print_enum(ndr, name, "ENUM", val, r);
1455                 ndr->flags = _flags_save_ENUM;
1456         }
1457 }
1458
1459 static enum ndr_err_code ndr_push_drsuapi_DsPartialAttributeSet(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsPartialAttributeSet *r)
1460 {
1461         uint32_t cntr_attids_0;
1462         if (ndr_flags & NDR_SCALARS) {
1463                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attids));
1464                 NDR_CHECK(ndr_push_align(ndr, 4));
1465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
1466                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
1468                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1469                         NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attids[cntr_attids_0]));
1470                 }
1471                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1472         }
1473         if (ndr_flags & NDR_BUFFERS) {
1474         }
1475         return NDR_ERR_SUCCESS;
1476 }
1477
1478 static enum ndr_err_code ndr_pull_drsuapi_DsPartialAttributeSet(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsPartialAttributeSet *r)
1479 {
1480         uint32_t cntr_attids_0;
1481         TALLOC_CTX *_mem_save_attids_0;
1482         if (ndr_flags & NDR_SCALARS) {
1483                 NDR_CHECK(ndr_pull_array_size(ndr, &r->attids));
1484                 NDR_CHECK(ndr_pull_align(ndr, 4));
1485                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attids));
1488                 if (r->num_attids < 1 || r->num_attids > 0x100000) {
1489                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1490                 }
1491                 NDR_PULL_ALLOC_N(ndr, r->attids, ndr_get_array_size(ndr, &r->attids));
1492                 _mem_save_attids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1493                 NDR_PULL_SET_MEM_CTX(ndr, r->attids, 0);
1494                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1495                         NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attids[cntr_attids_0]));
1496                 }
1497                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attids_0, 0);
1498                 if (r->attids) {
1499                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attids, r->num_attids));
1500                 }
1501                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1502         }
1503         if (ndr_flags & NDR_BUFFERS) {
1504         }
1505         return NDR_ERR_SUCCESS;
1506 }
1507
1508 _PUBLIC_ void ndr_print_drsuapi_DsPartialAttributeSet(struct ndr_print *ndr, const char *name, const struct drsuapi_DsPartialAttributeSet *r)
1509 {
1510         uint32_t cntr_attids_0;
1511         ndr_print_struct(ndr, name, "drsuapi_DsPartialAttributeSet");
1512         ndr->depth++;
1513         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
1514         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1515         ndr_print_uint32(ndr, "num_attids", r->num_attids);
1516         ndr->print(ndr, "%s: ARRAY(%d)", "attids", (int)r->num_attids);
1517         ndr->depth++;
1518         for (cntr_attids_0=0;cntr_attids_0<r->num_attids;cntr_attids_0++) {
1519                 char *idx_0=NULL;
1520                 if (asprintf(&idx_0, "[%d]", cntr_attids_0) != -1) {
1521                         ndr_print_drsuapi_DsAttributeId(ndr, "attids", r->attids[cntr_attids_0]);
1522                         free(idx_0);
1523                 }
1524         }
1525         ndr->depth--;
1526         ndr->depth--;
1527 }
1528
1529 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest8(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest8 *r)
1530 {
1531         if (ndr_flags & NDR_SCALARS) {
1532                 NDR_CHECK(ndr_push_align(ndr, 8));
1533                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1534                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1535                 if (r->naming_context == NULL) {
1536                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1537                 }
1538                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1539                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1540                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1541                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1544                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1545                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1546                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1547                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1548                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1549                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1550         }
1551         if (ndr_flags & NDR_BUFFERS) {
1552                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1553                 if (r->uptodateness_vector) {
1554                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1555                 }
1556                 if (r->partial_attribute_set) {
1557                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1558                 }
1559                 if (r->partial_attribute_set_ex) {
1560                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1561                 }
1562                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1563         }
1564         return NDR_ERR_SUCCESS;
1565 }
1566
1567 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest8(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest8 *r)
1568 {
1569         uint32_t _ptr_naming_context;
1570         TALLOC_CTX *_mem_save_naming_context_0;
1571         uint32_t _ptr_uptodateness_vector;
1572         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1573         uint32_t _ptr_partial_attribute_set;
1574         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1575         uint32_t _ptr_partial_attribute_set_ex;
1576         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1577         if (ndr_flags & NDR_SCALARS) {
1578                 NDR_CHECK(ndr_pull_align(ndr, 8));
1579                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1580                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1581                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1582                 if (_ptr_naming_context) {
1583                         NDR_PULL_ALLOC(ndr, r->naming_context);
1584                 } else {
1585                         r->naming_context = NULL;
1586                 }
1587                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1588                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1589                 if (_ptr_uptodateness_vector) {
1590                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1591                 } else {
1592                         r->uptodateness_vector = NULL;
1593                 }
1594                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1597                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1598                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1599                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1600                 if (_ptr_partial_attribute_set) {
1601                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1602                 } else {
1603                         r->partial_attribute_set = NULL;
1604                 }
1605                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1606                 if (_ptr_partial_attribute_set_ex) {
1607                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1608                 } else {
1609                         r->partial_attribute_set_ex = NULL;
1610                 }
1611                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1612                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1613         }
1614         if (ndr_flags & NDR_BUFFERS) {
1615                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1616                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1617                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1618                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1619                 if (r->uptodateness_vector) {
1620                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1621                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1622                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1623                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1624                 }
1625                 if (r->partial_attribute_set) {
1626                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1627                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1628                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1629                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1630                 }
1631                 if (r->partial_attribute_set_ex) {
1632                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1633                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1634                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1635                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1636                 }
1637                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1638         }
1639         return NDR_ERR_SUCCESS;
1640 }
1641
1642 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest8(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest8 *r)
1643 {
1644         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest8");
1645         ndr->depth++;
1646         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1647         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1648         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1649         ndr->depth++;
1650         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1651         ndr->depth--;
1652         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1653         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1654         ndr->depth++;
1655         if (r->uptodateness_vector) {
1656                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1657         }
1658         ndr->depth--;
1659         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1660         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1661         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1662         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1663         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1664         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1665         ndr->depth++;
1666         if (r->partial_attribute_set) {
1667                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1668         }
1669         ndr->depth--;
1670         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1671         ndr->depth++;
1672         if (r->partial_attribute_set_ex) {
1673                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1674         }
1675         ndr->depth--;
1676         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1677         ndr->depth--;
1678 }
1679
1680 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest10(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest10 *r)
1681 {
1682         if (ndr_flags & NDR_SCALARS) {
1683                 NDR_CHECK(ndr_push_align(ndr, 8));
1684                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1685                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1686                 if (r->naming_context == NULL) {
1687                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1688                 }
1689                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1690                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1691                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1692                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
1693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1695                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1696                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1697                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1698                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1699                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_flags));
1701                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1702         }
1703         if (ndr_flags & NDR_BUFFERS) {
1704                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1705                 if (r->uptodateness_vector) {
1706                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1707                 }
1708                 if (r->partial_attribute_set) {
1709                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1710                 }
1711                 if (r->partial_attribute_set_ex) {
1712                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1713                 }
1714                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1715         }
1716         return NDR_ERR_SUCCESS;
1717 }
1718
1719 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest10(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest10 *r)
1720 {
1721         uint32_t _ptr_naming_context;
1722         TALLOC_CTX *_mem_save_naming_context_0;
1723         uint32_t _ptr_uptodateness_vector;
1724         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1725         uint32_t _ptr_partial_attribute_set;
1726         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1727         uint32_t _ptr_partial_attribute_set_ex;
1728         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1729         if (ndr_flags & NDR_SCALARS) {
1730                 NDR_CHECK(ndr_pull_align(ndr, 8));
1731                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1732                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1733                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1734                 if (_ptr_naming_context) {
1735                         NDR_PULL_ALLOC(ndr, r->naming_context);
1736                 } else {
1737                         r->naming_context = NULL;
1738                 }
1739                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1740                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1741                 if (_ptr_uptodateness_vector) {
1742                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1743                 } else {
1744                         r->uptodateness_vector = NULL;
1745                 }
1746                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
1747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1749                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1750                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1751                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1752                 if (_ptr_partial_attribute_set) {
1753                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1754                 } else {
1755                         r->partial_attribute_set = NULL;
1756                 }
1757                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1758                 if (_ptr_partial_attribute_set_ex) {
1759                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1760                 } else {
1761                         r->partial_attribute_set_ex = NULL;
1762                 }
1763                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_flags));
1765                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1766         }
1767         if (ndr_flags & NDR_BUFFERS) {
1768                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1769                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1770                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1771                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1772                 if (r->uptodateness_vector) {
1773                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1774                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1775                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1776                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1777                 }
1778                 if (r->partial_attribute_set) {
1779                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1780                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1781                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1782                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1783                 }
1784                 if (r->partial_attribute_set_ex) {
1785                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1786                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1787                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1788                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1789                 }
1790                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1791         }
1792         return NDR_ERR_SUCCESS;
1793 }
1794
1795 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest10(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest10 *r)
1796 {
1797         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest10");
1798         ndr->depth++;
1799         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1800         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1801         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1802         ndr->depth++;
1803         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1804         ndr->depth--;
1805         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1806         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1807         ndr->depth++;
1808         if (r->uptodateness_vector) {
1809                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1810         }
1811         ndr->depth--;
1812         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
1813         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1814         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1815         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1816         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1817         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1818         ndr->depth++;
1819         if (r->partial_attribute_set) {
1820                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1821         }
1822         ndr->depth--;
1823         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1824         ndr->depth++;
1825         if (r->partial_attribute_set_ex) {
1826                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1827         }
1828         ndr->depth--;
1829         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1830         ndr_print_uint32(ndr, "more_flags", r->more_flags);
1831         ndr->depth--;
1832 }
1833
1834 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesRequest *r)
1835 {
1836         if (ndr_flags & NDR_SCALARS) {
1837                 int level = ndr_push_get_switch_value(ndr, r);
1838                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
1839                 NDR_CHECK(ndr_push_union_align(ndr, 8));
1840                 switch (level) {
1841                         case 5: {
1842                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1843                         break; }
1844
1845                         case 8: {
1846                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1847                         break; }
1848
1849                         case 10: {
1850                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1851                         break; }
1852
1853                         default:
1854                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1855                 }
1856         }
1857         if (ndr_flags & NDR_BUFFERS) {
1858                 int level = ndr_push_get_switch_value(ndr, r);
1859                 switch (level) {
1860                         case 5:
1861                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1862                         break;
1863
1864                         case 8:
1865                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1866                         break;
1867
1868                         case 10:
1869                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1870                         break;
1871
1872                         default:
1873                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1874                 }
1875         }
1876         return NDR_ERR_SUCCESS;
1877 }
1878
1879 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesRequest *r)
1880 {
1881         int level;
1882         int32_t _level;
1883         level = ndr_pull_get_switch_value(ndr, r);
1884         if (ndr_flags & NDR_SCALARS) {
1885                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
1886                 if (_level != level) {
1887                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1888                 }
1889                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
1890                 switch (level) {
1891                         case 5: {
1892                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1893                         break; }
1894
1895                         case 8: {
1896                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1897                         break; }
1898
1899                         case 10: {
1900                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1901                         break; }
1902
1903                         default:
1904                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1905                 }
1906         }
1907         if (ndr_flags & NDR_BUFFERS) {
1908                 switch (level) {
1909                         case 5:
1910                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1911                         break;
1912
1913                         case 8:
1914                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1915                         break;
1916
1917                         case 10:
1918                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1919                         break;
1920
1921                         default:
1922                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1923                 }
1924         }
1925         return NDR_ERR_SUCCESS;
1926 }
1927
1928 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesRequest *r)
1929 {
1930         int level;
1931         level = ndr_print_get_switch_value(ndr, r);
1932         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesRequest");
1933         switch (level) {
1934                 case 5:
1935                         ndr_print_drsuapi_DsGetNCChangesRequest5(ndr, "req5", &r->req5);
1936                 break;
1937
1938                 case 8:
1939                         ndr_print_drsuapi_DsGetNCChangesRequest8(ndr, "req8", &r->req8);
1940                 break;
1941
1942                 case 10:
1943                         ndr_print_drsuapi_DsGetNCChangesRequest10(ndr, "req10", &r->req10);
1944                 break;
1945
1946                 default:
1947                         ndr_print_bad_level(ndr, name, level);
1948         }
1949 }
1950
1951 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2 *r)
1952 {
1953         if (ndr_flags & NDR_SCALARS) {
1954                 NDR_CHECK(ndr_push_align(ndr, 8));
1955                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1956                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
1957                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
1958                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1959         }
1960         if (ndr_flags & NDR_BUFFERS) {
1961         }
1962         return NDR_ERR_SUCCESS;
1963 }
1964
1965 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2 *r)
1966 {
1967         if (ndr_flags & NDR_SCALARS) {
1968                 NDR_CHECK(ndr_pull_align(ndr, 8));
1969                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1970                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
1971                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
1972                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1973         }
1974         if (ndr_flags & NDR_BUFFERS) {
1975         }
1976         return NDR_ERR_SUCCESS;
1977 }
1978
1979 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2 *r)
1980 {
1981         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2");
1982         ndr->depth++;
1983         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1984         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
1985         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
1986         ndr->depth--;
1987 }
1988
1989 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1990 {
1991         uint32_t cntr_cursors_0;
1992         if (ndr_flags & NDR_SCALARS) {
1993                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1994                 NDR_CHECK(ndr_push_align(ndr, 8));
1995                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
1996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1997                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1999                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
2000                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
2001                 }
2002                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2003         }
2004         if (ndr_flags & NDR_BUFFERS) {
2005         }
2006         return NDR_ERR_SUCCESS;
2007 }
2008
2009 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2CtrEx *r)
2010 {
2011         uint32_t cntr_cursors_0;
2012         TALLOC_CTX *_mem_save_cursors_0;
2013         if (ndr_flags & NDR_SCALARS) {
2014                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
2015                 NDR_CHECK(ndr_pull_align(ndr, 8));
2016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
2018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2019                 if (r->count > 0x100000) {
2020                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2021                 }
2022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
2023                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
2024                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
2025                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
2026                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
2027                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
2028                 }
2029                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
2030                 if (r->cursors) {
2031                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
2032                 }
2033                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2034         }
2035         if (ndr_flags & NDR_BUFFERS) {
2036         }
2037         return NDR_ERR_SUCCESS;
2038 }
2039
2040 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2CtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2CtrEx *r)
2041 {
2042         uint32_t cntr_cursors_0;
2043         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2CtrEx");
2044         ndr->depth++;
2045         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
2046         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
2047         ndr_print_uint32(ndr, "count", r->count);
2048         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
2049         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
2050         ndr->depth++;
2051         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
2052                 char *idx_0=NULL;
2053                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
2054                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
2055                         free(idx_0);
2056                 }
2057         }
2058         ndr->depth--;
2059         ndr->depth--;
2060 }
2061
2062 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValue(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValue *r)
2063 {
2064         if (ndr_flags & NDR_SCALARS) {
2065                 NDR_CHECK(ndr_push_align(ndr, 5));
2066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->blob, 0)));
2067                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->blob));
2068                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2069         }
2070         if (ndr_flags & NDR_BUFFERS) {
2071                 if (r->blob) {
2072                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->blob));
2073                 }
2074         }
2075         return NDR_ERR_SUCCESS;
2076 }
2077
2078 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValue *r)
2079 {
2080         uint32_t _ptr_blob;
2081         TALLOC_CTX *_mem_save_blob_0;
2082         if (ndr_flags & NDR_SCALARS) {
2083                 NDR_CHECK(ndr_pull_align(ndr, 5));
2084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2085                 if (r->__ndr_size > 10485760) {
2086                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2087                 }
2088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_blob));
2089                 if (_ptr_blob) {
2090                         NDR_PULL_ALLOC(ndr, r->blob);
2091                 } else {
2092                         r->blob = NULL;
2093                 }
2094                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2095         }
2096         if (ndr_flags & NDR_BUFFERS) {
2097                 if (r->blob) {
2098                         _mem_save_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
2099                         NDR_PULL_SET_MEM_CTX(ndr, r->blob, 0);
2100                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->blob));
2101                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_blob_0, 0);
2102                 }
2103         }
2104         return NDR_ERR_SUCCESS;
2105 }
2106
2107 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValue(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValue *r)
2108 {
2109         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
2110         ndr->depth++;
2111         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_DATA_BLOB(0, r->blob, 0):r->__ndr_size);
2112         ndr_print_ptr(ndr, "blob", r->blob);
2113         ndr->depth++;
2114         if (r->blob) {
2115                 ndr_print_DATA_BLOB(ndr, "blob", *r->blob);
2116         }
2117         ndr->depth--;
2118         ndr->depth--;
2119 }
2120
2121 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValueCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValueCtr *r)
2122 {
2123         uint32_t cntr_values_1;
2124         if (ndr_flags & NDR_SCALARS) {
2125                 NDR_CHECK(ndr_push_align(ndr, 5));
2126                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
2127                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->values));
2128                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2129         }
2130         if (ndr_flags & NDR_BUFFERS) {
2131                 if (r->values) {
2132                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_values));
2133                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2134                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2135                         }
2136                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2137                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2138                         }
2139                 }
2140         }
2141         return NDR_ERR_SUCCESS;
2142 }
2143
2144 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValueCtr *r)
2145 {
2146         uint32_t _ptr_values;
2147         uint32_t cntr_values_1;
2148         TALLOC_CTX *_mem_save_values_0;
2149         TALLOC_CTX *_mem_save_values_1;
2150         if (ndr_flags & NDR_SCALARS) {
2151                 NDR_CHECK(ndr_pull_align(ndr, 5));
2152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_values));
2153                 if (r->num_values > 10485760) {
2154                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2155                 }
2156                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_values));
2157                 if (_ptr_values) {
2158                         NDR_PULL_ALLOC(ndr, r->values);
2159                 } else {
2160                         r->values = NULL;
2161                 }
2162                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2163         }
2164         if (ndr_flags & NDR_BUFFERS) {
2165                 if (r->values) {
2166                         _mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
2167                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2168                         NDR_CHECK(ndr_pull_array_size(ndr, &r->values));
2169                         NDR_PULL_ALLOC_N(ndr, r->values, ndr_get_array_size(ndr, &r->values));
2170                         _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
2171                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2172                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2173                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2174                         }
2175                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2176                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2177                         }
2178                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
2179                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_0, 0);
2180                 }
2181                 if (r->values) {
2182                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->values, r->num_values));
2183                 }
2184         }
2185         return NDR_ERR_SUCCESS;
2186 }
2187
2188 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValueCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValueCtr *r)
2189 {
2190         uint32_t cntr_values_1;
2191         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValueCtr");
2192         ndr->depth++;
2193         ndr_print_uint32(ndr, "num_values", r->num_values);
2194         ndr_print_ptr(ndr, "values", r->values);
2195         ndr->depth++;
2196         if (r->values) {
2197                 ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->num_values);
2198                 ndr->depth++;
2199                 for (cntr_values_1=0;cntr_values_1<r->num_values;cntr_values_1++) {
2200                         char *idx_1=NULL;
2201                         if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
2202                                 ndr_print_drsuapi_DsAttributeValue(ndr, "values", &r->values[cntr_values_1]);
2203                                 free(idx_1);
2204                         }
2205                 }
2206                 ndr->depth--;
2207         }
2208         ndr->depth--;
2209         ndr->depth--;
2210 }
2211
2212 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2213 {
2214         if (ndr_flags & NDR_SCALARS) {
2215                 NDR_CHECK(ndr_push_align(ndr, 4));
2216                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
2217                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2218                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2219                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2221                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2222                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2223         }
2224         if (ndr_flags & NDR_BUFFERS) {
2225                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2226         }
2227         return NDR_ERR_SUCCESS;
2228 }
2229
2230 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3 *r)
2231 {
2232         if (ndr_flags & NDR_SCALARS) {
2233                 NDR_CHECK(ndr_pull_align(ndr, 4));
2234                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2236                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2237                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2239                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2240                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2241         }
2242         if (ndr_flags & NDR_BUFFERS) {
2243                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2244         }
2245         return NDR_ERR_SUCCESS;
2246 }
2247
2248 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2249 {
2250         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3");
2251         ndr->depth++;
2252         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);
2253         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);
2254         ndr_print_GUID(ndr, "guid", &r->guid);
2255         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2256         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2257         ndr_print_string(ndr, "dn", r->dn);
2258         ndr->depth--;
2259 }
2260
2261 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3(const struct drsuapi_DsReplicaObjectIdentifier3 *r, struct smb_iconv_convenience *ic, int flags)
2262 {
2263         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3, ic);
2264 }
2265
2266 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2267 {
2268         if (ndr_flags & NDR_SCALARS) {
2269                 NDR_CHECK(ndr_push_align(ndr, 4));
2270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(r, ndr->iconv_convenience, ndr->flags)));
2271                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2272                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2273                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2274                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2275                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->binary.length + 4));
2277                 {
2278                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2279                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2280                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
2281                         ndr->flags = _flags_save_DATA_BLOB;
2282                 }
2283                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2284         }
2285         if (ndr_flags & NDR_BUFFERS) {
2286                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2287         }
2288         return NDR_ERR_SUCCESS;
2289 }
2290
2291 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2292 {
2293         if (ndr_flags & NDR_SCALARS) {
2294                 NDR_CHECK(ndr_pull_align(ndr, 4));
2295                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2297                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2298                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2299                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2300                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
2302                 {
2303                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2305                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
2306                         ndr->flags = _flags_save_DATA_BLOB;
2307                 }
2308                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2309         }
2310         if (ndr_flags & NDR_BUFFERS) {
2311                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2312         }
2313         return NDR_ERR_SUCCESS;
2314 }
2315
2316 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2317 {
2318         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3Binary");
2319         ndr->depth++;
2320         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(r, ndr->iconv_convenience, ndr->flags):r->__ndr_size);
2321         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);
2322         ndr_print_GUID(ndr, "guid", &r->guid);
2323         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2324         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2325         ndr_print_string(ndr, "dn", r->dn);
2326         ndr_print_uint32(ndr, "__ndr_size_binary", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->binary.length + 4:r->__ndr_size_binary);
2327         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
2328         ndr->depth--;
2329 }
2330
2331 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttribute *r)
2332 {
2333         if (ndr_flags & NDR_SCALARS) {
2334                 NDR_CHECK(ndr_push_align(ndr, 5));
2335                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2336                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2337                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2338         }
2339         if (ndr_flags & NDR_BUFFERS) {
2340                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2341         }
2342         return NDR_ERR_SUCCESS;
2343 }
2344
2345 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttribute *r)
2346 {
2347         if (ndr_flags & NDR_SCALARS) {
2348                 NDR_CHECK(ndr_pull_align(ndr, 5));
2349                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2350                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2351                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2352         }
2353         if (ndr_flags & NDR_BUFFERS) {
2354                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2355         }
2356         return NDR_ERR_SUCCESS;
2357 }
2358
2359 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttribute *r)
2360 {
2361         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttribute");
2362         ndr->depth++;
2363         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2364         ndr_print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr);
2365         ndr->depth--;
2366 }
2367
2368 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttributeCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttributeCtr *r)
2369 {
2370         uint32_t cntr_attributes_1;
2371         if (ndr_flags & NDR_SCALARS) {
2372                 NDR_CHECK(ndr_push_align(ndr, 5));
2373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2374                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
2375                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2376         }
2377         if (ndr_flags & NDR_BUFFERS) {
2378                 if (r->attributes) {
2379                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attributes));
2380                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2381                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2382                         }
2383                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2384                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2385                         }
2386                 }
2387         }
2388         return NDR_ERR_SUCCESS;
2389 }
2390
2391 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttributeCtr *r)
2392 {
2393         uint32_t _ptr_attributes;
2394         uint32_t cntr_attributes_1;
2395         TALLOC_CTX *_mem_save_attributes_0;
2396         TALLOC_CTX *_mem_save_attributes_1;
2397         if (ndr_flags & NDR_SCALARS) {
2398                 NDR_CHECK(ndr_pull_align(ndr, 5));
2399                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attributes));
2400                 if (r->num_attributes > 1048576) {
2401                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2402                 }
2403                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
2404                 if (_ptr_attributes) {
2405                         NDR_PULL_ALLOC(ndr, r->attributes);
2406                 } else {
2407                         r->attributes = NULL;
2408                 }
2409                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2410         }
2411         if (ndr_flags & NDR_BUFFERS) {
2412                 if (r->attributes) {
2413                         _mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2414                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2415                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
2416                         NDR_PULL_ALLOC_N(ndr, r->attributes, ndr_get_array_size(ndr, &r->attributes));
2417                         _mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2418                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2419                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2420                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2421                         }
2422                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2423                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2424                         }
2425                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
2426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);
2427                 }
2428                 if (r->attributes) {
2429                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->num_attributes));
2430                 }
2431         }
2432         return NDR_ERR_SUCCESS;
2433 }
2434
2435 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttributeCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttributeCtr *r)
2436 {
2437         uint32_t cntr_attributes_1;
2438         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttributeCtr");
2439         ndr->depth++;
2440         ndr_print_uint32(ndr, "num_attributes", r->num_attributes);
2441         ndr_print_ptr(ndr, "attributes", r->attributes);
2442         ndr->depth++;
2443         if (r->attributes) {
2444                 ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->num_attributes);
2445                 ndr->depth++;
2446                 for (cntr_attributes_1=0;cntr_attributes_1<r->num_attributes;cntr_attributes_1++) {
2447                         char *idx_1=NULL;
2448                         if (asprintf(&idx_1, "[%d]", cntr_attributes_1) != -1) {
2449                                 ndr_print_drsuapi_DsReplicaAttribute(ndr, "attributes", &r->attributes[cntr_attributes_1]);
2450                                 free(idx_1);
2451                         }
2452                 }
2453                 ndr->depth--;
2454         }
2455         ndr->depth--;
2456         ndr->depth--;
2457 }
2458
2459 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2460 {
2461         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2462         return NDR_ERR_SUCCESS;
2463 }
2464
2465 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2466 {
2467         uint32_t v;
2468         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2469         *r = v;
2470         return NDR_ERR_SUCCESS;
2471 }
2472
2473 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2474 {
2475         ndr_print_uint32(ndr, name, r);
2476         ndr->depth++;
2477         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER", DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER, r);
2478         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC", DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC, r);
2479         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY", DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY, r);
2480         ndr->depth--;
2481 }
2482
2483 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObject(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObject *r)
2484 {
2485         if (ndr_flags & NDR_SCALARS) {
2486                 NDR_CHECK(ndr_push_align(ndr, 5));
2487                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2488                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, r->flags));
2489                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2490                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2491         }
2492         if (ndr_flags & NDR_BUFFERS) {
2493                 if (r->identifier) {
2494                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2495                 }
2496                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2497         }
2498         return NDR_ERR_SUCCESS;
2499 }
2500
2501 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObject *r)
2502 {
2503         uint32_t _ptr_identifier;
2504         TALLOC_CTX *_mem_save_identifier_0;
2505         if (ndr_flags & NDR_SCALARS) {
2506                 NDR_CHECK(ndr_pull_align(ndr, 5));
2507                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2508                 if (_ptr_identifier) {
2509                         NDR_PULL_ALLOC(ndr, r->identifier);
2510                 } else {
2511                         r->identifier = NULL;
2512                 }
2513                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, &r->flags));
2514                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2515                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2516         }
2517         if (ndr_flags & NDR_BUFFERS) {
2518                 if (r->identifier) {
2519                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2520                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2521                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2522                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2523                 }
2524                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2525         }
2526         return NDR_ERR_SUCCESS;
2527 }
2528
2529 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObject(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObject *r)
2530 {
2531         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObject");
2532         ndr->depth++;
2533         ndr_print_ptr(ndr, "identifier", r->identifier);
2534         ndr->depth++;
2535         if (r->identifier) {
2536                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2537         }
2538         ndr->depth--;
2539         ndr_print_drsuapi_DsReplicaObjectFlags(ndr, "flags", r->flags);
2540         ndr_print_drsuapi_DsReplicaAttributeCtr(ndr, "attribute_ctr", &r->attribute_ctr);
2541         ndr->depth--;
2542 }
2543
2544 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaData *r)
2545 {
2546         if (ndr_flags & NDR_SCALARS) {
2547                 NDR_CHECK(ndr_push_align(ndr, 8));
2548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2549                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
2550                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2551                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
2552                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2553         }
2554         if (ndr_flags & NDR_BUFFERS) {
2555         }
2556         return NDR_ERR_SUCCESS;
2557 }
2558
2559 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaData *r)
2560 {
2561         if (ndr_flags & NDR_SCALARS) {
2562                 NDR_CHECK(ndr_pull_align(ndr, 8));
2563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2564                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
2565                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2566                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
2567                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2568         }
2569         if (ndr_flags & NDR_BUFFERS) {
2570         }
2571         return NDR_ERR_SUCCESS;
2572 }
2573
2574 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaData *r)
2575 {
2576         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaData");
2577         ndr->depth++;
2578         ndr_print_uint32(ndr, "version", r->version);
2579         ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
2580         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
2581         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
2582         ndr->depth--;
2583 }
2584
2585 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaDataCtr *r)
2586 {
2587         uint32_t cntr_meta_data_0;
2588         if (ndr_flags & NDR_SCALARS) {
2589                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
2590                 NDR_CHECK(ndr_push_align(ndr, 8));
2591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2592                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2593                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2594                 }
2595                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2596         }
2597         if (ndr_flags & NDR_BUFFERS) {
2598         }
2599         return NDR_ERR_SUCCESS;
2600 }
2601
2602 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaDataCtr *r)
2603 {
2604         uint32_t cntr_meta_data_0;
2605         TALLOC_CTX *_mem_save_meta_data_0;
2606         if (ndr_flags & NDR_SCALARS) {
2607                 NDR_CHECK(ndr_pull_array_size(ndr, &r->meta_data));
2608                 NDR_CHECK(ndr_pull_align(ndr, 8));
2609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2610                 if (r->count > 1048576) {
2611                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2612                 }
2613                 NDR_PULL_ALLOC_N(ndr, r->meta_data, ndr_get_array_size(ndr, &r->meta_data));
2614                 _mem_save_meta_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2615                 NDR_PULL_SET_MEM_CTX(ndr, r->meta_data, 0);
2616                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2617                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2618                 }
2619                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_0, 0);
2620                 if (r->meta_data) {
2621                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->meta_data, r->count));
2622                 }
2623                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2624         }
2625         if (ndr_flags & NDR_BUFFERS) {
2626         }
2627         return NDR_ERR_SUCCESS;
2628 }
2629
2630 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaDataCtr *r)
2631 {
2632         uint32_t cntr_meta_data_0;
2633         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaDataCtr");
2634         ndr->depth++;
2635         ndr_print_uint32(ndr, "count", r->count);
2636         ndr->print(ndr, "%s: ARRAY(%d)", "meta_data", (int)r->count);
2637         ndr->depth++;
2638         for (cntr_meta_data_0=0;cntr_meta_data_0<r->count;cntr_meta_data_0++) {
2639                 char *idx_0=NULL;
2640                 if (asprintf(&idx_0, "[%d]", cntr_meta_data_0) != -1) {
2641                         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data[cntr_meta_data_0]);
2642                         free(idx_0);
2643                 }
2644         }
2645         ndr->depth--;
2646         ndr->depth--;
2647 }
2648
2649 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItemEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItemEx *r)
2650 {
2651         if (ndr_flags & NDR_SCALARS) {
2652                 NDR_CHECK(ndr_push_align(ndr, 5));
2653                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
2654                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2655                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_nc_prefix));
2656                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parent_object_guid));
2657                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->meta_data_ctr));
2658                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2659         }
2660         if (ndr_flags & NDR_BUFFERS) {
2661                 if (r->next_object) {
2662                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2663                 }
2664                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2665                 if (r->parent_object_guid) {
2666                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2667                 }
2668                 if (r->meta_data_ctr) {
2669                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2670                 }
2671         }
2672         return NDR_ERR_SUCCESS;
2673 }
2674
2675 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItemEx *r)
2676 {
2677         uint32_t _ptr_next_object;
2678         TALLOC_CTX *_mem_save_next_object_0;
2679         uint32_t _ptr_parent_object_guid;
2680         TALLOC_CTX *_mem_save_parent_object_guid_0;
2681         uint32_t _ptr_meta_data_ctr;
2682         TALLOC_CTX *_mem_save_meta_data_ctr_0;
2683         if (ndr_flags & NDR_SCALARS) {
2684                 NDR_CHECK(ndr_pull_align(ndr, 5));
2685                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
2686                 if (_ptr_next_object) {
2687                         NDR_PULL_ALLOC(ndr, r->next_object);
2688                 } else {
2689                         r->next_object = NULL;
2690                 }
2691                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2692                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_nc_prefix));
2693                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parent_object_guid));
2694                 if (_ptr_parent_object_guid) {
2695                         NDR_PULL_ALLOC(ndr, r->parent_object_guid);
2696                 } else {
2697                         r->parent_object_guid = NULL;
2698                 }
2699                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_meta_data_ctr));
2700                 if (_ptr_meta_data_ctr) {
2701                         NDR_PULL_ALLOC(ndr, r->meta_data_ctr);
2702                 } else {
2703                         r->meta_data_ctr = NULL;
2704                 }
2705                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2706         }
2707         if (ndr_flags & NDR_BUFFERS) {
2708                 if (r->next_object) {
2709                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2710                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
2711                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2712                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
2713                 }
2714                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2715                 if (r->parent_object_guid) {
2716                         _mem_save_parent_object_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2717                         NDR_PULL_SET_MEM_CTX(ndr, r->parent_object_guid, 0);
2718                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2719                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_object_guid_0, 0);
2720                 }
2721                 if (r->meta_data_ctr) {
2722                         _mem_save_meta_data_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2723                         NDR_PULL_SET_MEM_CTX(ndr, r->meta_data_ctr, 0);
2724                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2725                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_ctr_0, 0);
2726                 }
2727         }
2728         return NDR_ERR_SUCCESS;
2729 }
2730
2731 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1 *r)
2732 {
2733         if (ndr_flags & NDR_SCALARS) {
2734                 NDR_CHECK(ndr_push_align(ndr, 8));
2735                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2736                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2737                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2738                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2739                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2740                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2741                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2742                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55));
2745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2747                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2748         }
2749         if (ndr_flags & NDR_BUFFERS) {
2750                 if (r->naming_context) {
2751                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2752                 }
2753                 if (r->uptodateness_vector) {
2754                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2755                 }
2756                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2757                 if (r->first_object) {
2758                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2759                 }
2760         }
2761         return NDR_ERR_SUCCESS;
2762 }
2763
2764 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1 *r)
2765 {
2766         uint32_t _ptr_naming_context;
2767         TALLOC_CTX *_mem_save_naming_context_0;
2768         uint32_t _ptr_uptodateness_vector;
2769         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2770         uint32_t _ptr_first_object;
2771         TALLOC_CTX *_mem_save_first_object_0;
2772         if (ndr_flags & NDR_SCALARS) {
2773                 NDR_CHECK(ndr_pull_align(ndr, 8));
2774                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2775                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2776                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2777                 if (_ptr_naming_context) {
2778                         NDR_PULL_ALLOC(ndr, r->naming_context);
2779                 } else {
2780                         r->naming_context = NULL;
2781                 }
2782                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2783                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2784                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2785                 if (_ptr_uptodateness_vector) {
2786                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2787                 } else {
2788                         r->uptodateness_vector = NULL;
2789                 }
2790                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2791                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2795                 if (_ptr_first_object) {
2796                         NDR_PULL_ALLOC(ndr, r->first_object);
2797                 } else {
2798                         r->first_object = NULL;
2799                 }
2800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2801                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2802         }
2803         if (ndr_flags & NDR_BUFFERS) {
2804                 if (r->naming_context) {
2805                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2806                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2807                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2808                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2809                 }
2810                 if (r->uptodateness_vector) {
2811                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2812                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2813                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2814                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2815                 }
2816                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2817                 if (r->first_object) {
2818                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2819                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2820                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2821                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2822                 }
2823         }
2824         return NDR_ERR_SUCCESS;
2825 }
2826
2827 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1 *r)
2828 {
2829         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1");
2830         ndr->depth++;
2831         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2832         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2833         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2834         ndr->depth++;
2835         if (r->naming_context) {
2836                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2837         }
2838         ndr->depth--;
2839         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2840         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2841         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2842         ndr->depth++;
2843         if (r->uptodateness_vector) {
2844                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2845         }
2846         ndr->depth--;
2847         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2848         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2849         ndr_print_uint32(ndr, "object_count", r->object_count);
2850         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);
2851         ndr_print_ptr(ndr, "first_object", r->first_object);
2852         ndr->depth++;
2853         if (r->first_object) {
2854                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2855         }
2856         ndr->depth--;
2857         ndr_print_uint32(ndr, "more_data", r->more_data);
2858         ndr->depth--;
2859 }
2860
2861 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr1(const struct drsuapi_DsGetNCChangesCtr1 *r, struct smb_iconv_convenience *ic, int flags)
2862 {
2863         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr1, ic);
2864 }
2865
2866 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsLinkedAttributeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2867 {
2868         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2869         return NDR_ERR_SUCCESS;
2870 }
2871
2872 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsLinkedAttributeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2873 {
2874         uint32_t v;
2875         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2876         *r = v;
2877         return NDR_ERR_SUCCESS;
2878 }
2879
2880 _PUBLIC_ void ndr_print_drsuapi_DsLinkedAttributeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2881 {
2882         ndr_print_uint32(ndr, name, r);
2883         ndr->depth++;
2884         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE", DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE, r);
2885         ndr->depth--;
2886 }
2887
2888 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaLinkedAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaLinkedAttribute *r)
2889 {
2890         if (ndr_flags & NDR_SCALARS) {
2891                 NDR_CHECK(ndr_push_align(ndr, 8));
2892                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2893                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2894                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2895                 NDR_CHECK(ndr_push_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, r->flags));
2896                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_add_time));
2897                 NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2898                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2899         }
2900         if (ndr_flags & NDR_BUFFERS) {
2901                 if (r->identifier) {
2902                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2903                 }
2904                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2905         }
2906         return NDR_ERR_SUCCESS;
2907 }
2908
2909 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaLinkedAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaLinkedAttribute *r)
2910 {
2911         uint32_t _ptr_identifier;
2912         TALLOC_CTX *_mem_save_identifier_0;
2913         if (ndr_flags & NDR_SCALARS) {
2914                 NDR_CHECK(ndr_pull_align(ndr, 8));
2915                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2916                 if (_ptr_identifier) {
2917                         NDR_PULL_ALLOC(ndr, r->identifier);
2918                 } else {
2919                         r->identifier = NULL;
2920                 }
2921                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2922                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2923                 NDR_CHECK(ndr_pull_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, &r->flags));
2924                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_add_time));
2925                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2926                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2927         }
2928         if (ndr_flags & NDR_BUFFERS) {
2929                 if (r->identifier) {
2930                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2931                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2932                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2933                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2934                 }
2935                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2936         }
2937         return NDR_ERR_SUCCESS;
2938 }
2939
2940 _PUBLIC_ void ndr_print_drsuapi_DsReplicaLinkedAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaLinkedAttribute *r)
2941 {
2942         ndr_print_struct(ndr, name, "drsuapi_DsReplicaLinkedAttribute");
2943         ndr->depth++;
2944         ndr_print_ptr(ndr, "identifier", r->identifier);
2945         ndr->depth++;
2946         if (r->identifier) {
2947                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2948         }
2949         ndr->depth--;
2950         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2951         ndr_print_drsuapi_DsAttributeValue(ndr, "value", &r->value);
2952         ndr_print_drsuapi_DsLinkedAttributeFlags(ndr, "flags", r->flags);
2953         ndr_print_NTTIME_1sec(ndr, "originating_add_time", r->originating_add_time);
2954         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data);
2955         ndr->depth--;
2956 }
2957
2958 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6 *r)
2959 {
2960         uint32_t cntr_linked_attributes_1;
2961         if (ndr_flags & NDR_SCALARS) {
2962                 NDR_CHECK(ndr_push_align(ndr, 8));
2963                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2964                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2965                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2966                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2967                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2968                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2969                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2970                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2972                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55));
2973                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_object_count));
2976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_linked_attributes_count));
2977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2978                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linked_attributes));
2979                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->drs_error));
2980                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2981         }
2982         if (ndr_flags & NDR_BUFFERS) {
2983                 if (r->naming_context) {
2984                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2985                 }
2986                 if (r->uptodateness_vector) {
2987                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2988                 }
2989                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2990                 if (r->first_object) {
2991                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2992                 }
2993                 if (r->linked_attributes) {
2994                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->linked_attributes_count));
2995                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2996                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2997                         }
2998                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2999                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
3000                         }
3001                 }
3002         }
3003         return NDR_ERR_SUCCESS;
3004 }
3005
3006 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6 *r)
3007 {
3008         uint32_t _ptr_naming_context;
3009         TALLOC_CTX *_mem_save_naming_context_0;
3010         uint32_t _ptr_uptodateness_vector;
3011         TALLOC_CTX *_mem_save_uptodateness_vector_0;
3012         uint32_t _ptr_first_object;
3013         TALLOC_CTX *_mem_save_first_object_0;
3014         uint32_t _ptr_linked_attributes;
3015         uint32_t cntr_linked_attributes_1;
3016         TALLOC_CTX *_mem_save_linked_attributes_0;
3017         TALLOC_CTX *_mem_save_linked_attributes_1;
3018         if (ndr_flags & NDR_SCALARS) {
3019                 NDR_CHECK(ndr_pull_align(ndr, 8));
3020                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
3021                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
3022                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
3023                 if (_ptr_naming_context) {
3024                         NDR_PULL_ALLOC(ndr, r->naming_context);
3025                 } else {
3026                         r->naming_context = NULL;
3027                 }
3028                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
3029                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
3030                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
3031                 if (_ptr_uptodateness_vector) {
3032                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
3033                 } else {
3034                         r->uptodateness_vector = NULL;
3035                 }
3036                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
3037                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
3038                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
3039                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
3040                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
3041                 if (_ptr_first_object) {
3042                         NDR_PULL_ALLOC(ndr, r->first_object);
3043                 } else {
3044                         r->first_object = NULL;
3045                 }
3046                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
3047                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_object_count));
3048                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_linked_attributes_count));
3049                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linked_attributes_count));
3050                 if (r->linked_attributes_count > 1048576) {
3051                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3052                 }
3053                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linked_attributes));
3054                 if (_ptr_linked_attributes) {
3055                         NDR_PULL_ALLOC(ndr, r->linked_attributes);
3056                 } else {
3057                         r->linked_attributes = NULL;
3058                 }
3059                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->drs_error));
3060                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
3061         }
3062         if (ndr_flags & NDR_BUFFERS) {
3063                 if (r->naming_context) {
3064                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3065                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3066                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3068                 }
3069                 if (r->uptodateness_vector) {
3070                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
3071                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
3072                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
3073                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
3074                 }
3075                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
3076                 if (r->first_object) {
3077                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
3078                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
3079                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
3080                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
3081                 }
3082                 if (r->linked_attributes) {
3083                         _mem_save_linked_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
3084                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3085                         NDR_CHECK(ndr_pull_array_size(ndr, &r->linked_attributes));
3086                         NDR_PULL_ALLOC_N(ndr, r->linked_attributes, ndr_get_array_size(ndr, &r->linked_attributes));
3087                         _mem_save_linked_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
3088                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3089                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3090                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
3091                         }
3092                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3093                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
3094                         }
3095                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_1, 0);
3096                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_0, 0);
3097                 }
3098                 if (r->linked_attributes) {
3099                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->linked_attributes, r->linked_attributes_count));
3100                 }
3101         }
3102         return NDR_ERR_SUCCESS;
3103 }
3104
3105 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6 *r)
3106 {
3107         uint32_t cntr_linked_attributes_1;
3108         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6");
3109         ndr->depth++;
3110         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
3111         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
3112         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3113         ndr->depth++;
3114         if (r->naming_context) {
3115                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3116         }
3117         ndr->depth--;
3118         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
3119         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
3120         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
3121         ndr->depth++;
3122         if (r->uptodateness_vector) {
3123                 ndr_print_drsuapi_DsReplicaCursor2CtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
3124         }
3125         ndr->depth--;
3126         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
3127         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
3128         ndr_print_uint32(ndr, "object_count", r->object_count);
3129         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);
3130         ndr_print_ptr(ndr, "first_object", r->first_object);
3131         ndr->depth++;
3132         if (r->first_object) {
3133                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
3134         }
3135         ndr->depth--;
3136         ndr_print_uint32(ndr, "more_data", r->more_data);
3137         ndr_print_uint32(ndr, "nc_object_count", r->nc_object_count);
3138         ndr_print_uint32(ndr, "nc_linked_attributes_count", r->nc_linked_attributes_count);
3139         ndr_print_uint32(ndr, "linked_attributes_count", r->linked_attributes_count);
3140         ndr_print_ptr(ndr, "linked_attributes", r->linked_attributes);
3141         ndr->depth++;
3142         if (r->linked_attributes) {
3143                 ndr->print(ndr, "%s: ARRAY(%d)", "linked_attributes", (int)r->linked_attributes_count);
3144                 ndr->depth++;
3145                 for (cntr_linked_attributes_1=0;cntr_linked_attributes_1<r->linked_attributes_count;cntr_linked_attributes_1++) {
3146                         char *idx_1=NULL;
3147                         if (asprintf(&idx_1, "[%d]", cntr_linked_attributes_1) != -1) {
3148                                 ndr_print_drsuapi_DsReplicaLinkedAttribute(ndr, "linked_attributes", &r->linked_attributes[cntr_linked_attributes_1]);
3149                                 free(idx_1);
3150                         }
3151                 }
3152                 ndr->depth--;
3153         }
3154         ndr->depth--;
3155         ndr_print_WERROR(ndr, "drs_error", r->drs_error);
3156         ndr->depth--;
3157 }
3158
3159 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr6(const struct drsuapi_DsGetNCChangesCtr6 *r, struct smb_iconv_convenience *ic, int flags)
3160 {
3161         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr6, ic);
3162 }
3163
3164 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3165 {
3166         if (ndr_flags & NDR_SCALARS) {
3167                 NDR_CHECK(ndr_push_align(ndr, 1));
3168                 {
3169                         struct ndr_push *_ndr_ctr1;
3170                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3171                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3172                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3173                 }
3174                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3175         }
3176         if (ndr_flags & NDR_BUFFERS) {
3177         }
3178         return NDR_ERR_SUCCESS;
3179 }
3180
3181 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1TS *r)
3182 {
3183         if (ndr_flags & NDR_SCALARS) {
3184                 NDR_CHECK(ndr_pull_align(ndr, 1));
3185                 {
3186                         struct ndr_pull *_ndr_ctr1;
3187                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3188                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3189                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3190                 }
3191                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3192         }
3193         if (ndr_flags & NDR_BUFFERS) {
3194         }
3195         return NDR_ERR_SUCCESS;
3196 }
3197
3198 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3199 {
3200         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1TS");
3201         ndr->depth++;
3202         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3203         ndr->depth--;
3204 }
3205
3206 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3207 {
3208         if (ndr_flags & NDR_SCALARS) {
3209                 NDR_CHECK(ndr_push_align(ndr, 1));
3210                 {
3211                         struct ndr_push *_ndr_ctr6;
3212                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3213                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3214                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3215                 }
3216                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3217         }
3218         if (ndr_flags & NDR_BUFFERS) {
3219         }
3220         return NDR_ERR_SUCCESS;
3221 }
3222
3223 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6TS *r)
3224 {
3225         if (ndr_flags & NDR_SCALARS) {
3226                 NDR_CHECK(ndr_pull_align(ndr, 1));
3227                 {
3228                         struct ndr_pull *_ndr_ctr6;
3229                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3230                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3231                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3232                 }
3233                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3234         }
3235         if (ndr_flags & NDR_BUFFERS) {
3236         }
3237         return NDR_ERR_SUCCESS;
3238 }
3239
3240 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3241 {
3242         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6TS");
3243         ndr->depth++;
3244         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3245         ndr->depth--;
3246 }
3247
3248 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3249 {
3250         uint32_t _ptr_ts;
3251         TALLOC_CTX *_mem_save_ts_0;
3252         if (ndr_flags & NDR_SCALARS) {
3253                 NDR_CHECK(ndr_pull_align(ndr, 5));
3254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3256                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3257                 if (_ptr_ts) {
3258                         NDR_PULL_ALLOC(ndr, r->ts);
3259                 } else {
3260                         r->ts = NULL;
3261                 }
3262                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3263         }
3264         if (ndr_flags & NDR_BUFFERS) {
3265                 if (r->ts) {
3266                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3267                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3268                         {
3269                                 struct ndr_pull *_ndr_ts;
3270                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3271                                 {
3272                                         struct ndr_pull *_ndr_ts_compressed;
3273                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3274                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3275                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3276                                 }
3277                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3278                         }
3279                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3280                 }
3281         }
3282         return NDR_ERR_SUCCESS;
3283 }
3284
3285 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3286 {
3287         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr1");
3288         ndr->depth++;
3289         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3290         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3291         ndr_print_ptr(ndr, "ts", r->ts);
3292         ndr->depth++;
3293         if (r->ts) {
3294                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3295         }
3296         ndr->depth--;
3297         ndr->depth--;
3298 }
3299
3300 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3301 {
3302         uint32_t _ptr_ts;
3303         TALLOC_CTX *_mem_save_ts_0;
3304         if (ndr_flags & NDR_SCALARS) {
3305                 NDR_CHECK(ndr_pull_align(ndr, 5));
3306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3307                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3308                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3309                 if (_ptr_ts) {
3310                         NDR_PULL_ALLOC(ndr, r->ts);
3311                 } else {
3312                         r->ts = NULL;
3313                 }
3314                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3315         }
3316         if (ndr_flags & NDR_BUFFERS) {
3317                 if (r->ts) {
3318                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3319                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3320                         {
3321                                 struct ndr_pull *_ndr_ts;
3322                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3323                                 {
3324                                         struct ndr_pull *_ndr_ts_compressed;
3325                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3326                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3327                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3328                                 }
3329                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3330                         }
3331                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3332                 }
3333         }
3334         return NDR_ERR_SUCCESS;
3335 }
3336
3337 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3338 {
3339         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr6");
3340         ndr->depth++;
3341         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3342         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3343         ndr_print_ptr(ndr, "ts", r->ts);
3344         ndr->depth++;
3345         if (r->ts) {
3346                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3347         }
3348         ndr->depth--;
3349         ndr->depth--;
3350 }
3351
3352 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3353 {
3354         uint32_t _ptr_ts;
3355         TALLOC_CTX *_mem_save_ts_0;
3356         if (ndr_flags & NDR_SCALARS) {
3357                 NDR_CHECK(ndr_pull_align(ndr, 5));
3358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3360                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3361                 if (_ptr_ts) {
3362                         NDR_PULL_ALLOC(ndr, r->ts);
3363                 } else {
3364                         r->ts = NULL;
3365                 }
3366                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3367         }
3368         if (ndr_flags & NDR_BUFFERS) {
3369                 if (r->ts) {
3370                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3371                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3372                         {
3373                                 struct ndr_pull *_ndr_ts;
3374                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3375                                 {
3376                                         struct ndr_pull *_ndr_ts_compressed;
3377                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3378                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3379                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3380                                 }
3381                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3382                         }
3383                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3384                 }
3385         }
3386         return NDR_ERR_SUCCESS;
3387 }
3388
3389 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3390 {
3391         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr1");
3392         ndr->depth++;
3393         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3394         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3395         ndr_print_ptr(ndr, "ts", r->ts);
3396         ndr->depth++;
3397         if (r->ts) {
3398                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3399         }
3400         ndr->depth--;
3401         ndr->depth--;
3402 }
3403
3404 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3405 {
3406         uint32_t _ptr_ts;
3407         TALLOC_CTX *_mem_save_ts_0;
3408         if (ndr_flags & NDR_SCALARS) {
3409                 NDR_CHECK(ndr_pull_align(ndr, 5));
3410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3412                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3413                 if (_ptr_ts) {
3414                         NDR_PULL_ALLOC(ndr, r->ts);
3415                 } else {
3416                         r->ts = NULL;
3417                 }
3418                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3419         }
3420         if (ndr_flags & NDR_BUFFERS) {
3421                 if (r->ts) {
3422                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3423                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3424                         {
3425                                 struct ndr_pull *_ndr_ts;
3426                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3427                                 {
3428                                         struct ndr_pull *_ndr_ts_compressed;
3429                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3430                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3431                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3432                                 }
3433                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3434                         }
3435                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3436                 }
3437         }
3438         return NDR_ERR_SUCCESS;
3439 }
3440
3441 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3442 {
3443         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr6");
3444         ndr->depth++;
3445         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3446         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3447         ndr_print_ptr(ndr, "ts", r->ts);
3448         ndr->depth++;
3449         if (r->ts) {
3450                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3451         }
3452         ndr->depth--;
3453         ndr->depth--;
3454 }
3455
3456 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressionType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType r)
3457 {
3458         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
3459         return NDR_ERR_SUCCESS;
3460 }
3461
3462 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressionType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType *r)
3463 {
3464         uint16_t v;
3465         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
3466         *r = v;
3467         return NDR_ERR_SUCCESS;
3468 }
3469
3470 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressionType(struct ndr_print *ndr, const char *name, enum drsuapi_DsGetNCChangesCompressionType r)
3471 {
3472         const char *val = NULL;
3473
3474         switch (r) {
3475                 case DRSUAPI_COMPRESSION_TYPE_MSZIP: val = "DRSUAPI_COMPRESSION_TYPE_MSZIP"; break;
3476                 case DRSUAPI_COMPRESSION_TYPE_XPRESS: val = "DRSUAPI_COMPRESSION_TYPE_XPRESS"; break;
3477         }
3478         ndr_print_enum(ndr, name, "ENUM", val, r);
3479 }
3480
3481 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3482 {
3483         {
3484                 uint32_t _flags_save_UNION = ndr->flags;
3485                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3486                 if (ndr_flags & NDR_SCALARS) {
3487                         int level = ndr_push_get_switch_value(ndr, r);
3488                         NDR_CHECK(ndr_push_union_align(ndr, 5));
3489                         switch (level) {
3490                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3491                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3492                                 break; }
3493
3494                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3495                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3496                                 break; }
3497
3498                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3499                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3500                                 break; }
3501
3502                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3503                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3504                                 break; }
3505
3506                                 default:
3507                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3508                         }
3509                 }
3510                 if (ndr_flags & NDR_BUFFERS) {
3511                         int level = ndr_push_get_switch_value(ndr, r);
3512                         switch (level) {
3513                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3514                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3515                                 break;
3516
3517                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3518                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3519                                 break;
3520
3521                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3522                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3523                                 break;
3524
3525                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3526                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3527                                 break;
3528
3529                                 default:
3530                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3531                         }
3532                 }
3533                 ndr->flags = _flags_save_UNION;
3534         }
3535         return NDR_ERR_SUCCESS;
3536 }
3537
3538 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCompressedCtr *r)
3539 {
3540         int level;
3541         {
3542                 uint32_t _flags_save_UNION = ndr->flags;
3543                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3544                 level = ndr_pull_get_switch_value(ndr, r);
3545                 if (ndr_flags & NDR_SCALARS) {
3546                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
3547                         switch (level) {
3548                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3549                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3550                                 break; }
3551
3552                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3553                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3554                                 break; }
3555
3556                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3557                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3558                                 break; }
3559
3560                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3561                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3562                                 break; }
3563
3564                                 default:
3565                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3566                         }
3567                 }
3568                 if (ndr_flags & NDR_BUFFERS) {
3569                         switch (level) {
3570                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3571                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3572                                 break;
3573
3574                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3575                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3576                                 break;
3577
3578                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3579                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3580                                 break;
3581
3582                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3583                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3584                                 break;
3585
3586                                 default:
3587                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3588                         }
3589                 }
3590                 ndr->flags = _flags_save_UNION;
3591         }
3592         return NDR_ERR_SUCCESS;
3593 }
3594
3595 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3596 {
3597         int level;
3598         {
3599                 uint32_t _flags_save_UNION = ndr->flags;
3600                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3601                 level = ndr_print_get_switch_value(ndr, r);
3602                 ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCompressedCtr");
3603                 switch (level) {
3604                         case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3605                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3606                         break;
3607
3608                         case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3609                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, "mszip6", &r->mszip6);
3610                         break;
3611
3612                         case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3613                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, "xpress1", &r->xpress1);
3614                         break;
3615
3616                         case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3617                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, "xpress6", &r->xpress6);
3618                         break;
3619
3620                         default:
3621                                 ndr_print_bad_level(ndr, name, level);
3622                 }
3623                 ndr->flags = _flags_save_UNION;
3624         }
3625 }
3626
3627 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr2 *r)
3628 {
3629         if (ndr_flags & NDR_SCALARS) {
3630                 NDR_CHECK(ndr_push_align(ndr, 5));
3631                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3632                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3633         }
3634         if (ndr_flags & NDR_BUFFERS) {
3635                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3636         }
3637         return NDR_ERR_SUCCESS;
3638 }
3639
3640 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr2 *r)
3641 {
3642         if (ndr_flags & NDR_SCALARS) {
3643                 NDR_CHECK(ndr_pull_align(ndr, 5));
3644                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3645                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3646         }
3647         if (ndr_flags & NDR_BUFFERS) {
3648                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3649         }
3650         return NDR_ERR_SUCCESS;
3651 }
3652
3653 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr2 *r)
3654 {
3655         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr2");
3656         ndr->depth++;
3657         ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3658         ndr->depth--;
3659 }
3660
3661 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr7 *r)
3662 {
3663         if (ndr_flags & NDR_SCALARS) {
3664                 NDR_CHECK(ndr_push_align(ndr, 5));
3665                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
3666                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, r->type));
3667                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3668                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3669                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3670         }
3671         if (ndr_flags & NDR_BUFFERS) {
3672                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3673         }
3674         return NDR_ERR_SUCCESS;
3675 }
3676
3677 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr7 *r)
3678 {
3679         if (ndr_flags & NDR_SCALARS) {
3680                 NDR_CHECK(ndr_pull_align(ndr, 5));
3681                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
3682                 if (r->level < 0 || r->level > 6) {
3683                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3684                 }
3685                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, &r->type));
3686                 if (r->type < 2 || r->type > 3) {
3687                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3688                 }
3689                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3690                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3691                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3692         }
3693         if (ndr_flags & NDR_BUFFERS) {
3694                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3695         }
3696         return NDR_ERR_SUCCESS;
3697 }
3698
3699 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr7(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr7 *r)
3700 {
3701         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr7");
3702         ndr->depth++;
3703         ndr_print_int32(ndr, "level", r->level);
3704         ndr_print_drsuapi_DsGetNCChangesCompressionType(ndr, "type", r->type);
3705         ndr_print_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16));
3706         ndr_print_drsuapi_DsGetNCChangesCompressedCtr(ndr, "ctr", &r->ctr);
3707         ndr->depth--;
3708 }
3709
3710 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCtr *r)
3711 {
3712         if (ndr_flags & NDR_SCALARS) {
3713                 int level = ndr_push_get_switch_value(ndr, r);
3714                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3715                 NDR_CHECK(ndr_push_union_align(ndr, 8));
3716                 switch (level) {
3717                         case 1: {
3718                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3719                         break; }
3720
3721                         case 2: {
3722                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3723                         break; }
3724
3725                         case 6: {
3726                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3727                         break; }
3728
3729                         case 7: {
3730                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3731                         break; }
3732
3733                         default:
3734                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3735                 }
3736         }
3737         if (ndr_flags & NDR_BUFFERS) {
3738                 int level = ndr_push_get_switch_value(ndr, r);
3739                 switch (level) {
3740                         case 1:
3741                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3742                         break;
3743
3744                         case 2:
3745                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3746                         break;
3747
3748                         case 6:
3749                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3750                         break;
3751
3752                         case 7:
3753                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3754                         break;
3755
3756                         default:
3757                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3758                 }
3759         }
3760         return NDR_ERR_SUCCESS;
3761 }
3762
3763 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCtr *r)
3764 {
3765         int level;
3766         int32_t _level;
3767         level = ndr_pull_get_switch_value(ndr, r);
3768         if (ndr_flags & NDR_SCALARS) {
3769                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3770                 if (_level != level) {
3771                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3772                 }
3773                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
3774                 switch (level) {
3775                         case 1: {
3776                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3777                         break; }
3778
3779                         case 2: {
3780                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3781                         break; }
3782
3783                         case 6: {
3784                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3785                         break; }
3786
3787                         case 7: {
3788                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3789                         break; }
3790
3791                         default:
3792                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3793                 }
3794         }
3795         if (ndr_flags & NDR_BUFFERS) {
3796                 switch (level) {
3797                         case 1:
3798                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3799                         break;
3800
3801                         case 2:
3802                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3803                         break;
3804
3805                         case 6:
3806                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3807                         break;
3808
3809                         case 7:
3810                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3811                         break;
3812
3813                         default:
3814                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3815                 }
3816         }
3817         return NDR_ERR_SUCCESS;
3818 }
3819
3820 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCtr *r)
3821 {
3822         int level;
3823         level = ndr_print_get_switch_value(ndr, r);
3824         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCtr");
3825         switch (level) {
3826                 case 1:
3827                         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3828                 break;
3829
3830                 case 2:
3831                         ndr_print_drsuapi_DsGetNCChangesCtr2(ndr, "ctr2", &r->ctr2);
3832                 break;
3833
3834                 case 6:
3835                         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3836                 break;
3837
3838                 case 7:
3839                         ndr_print_drsuapi_DsGetNCChangesCtr7(ndr, "ctr7", &r->ctr7);
3840                 break;
3841
3842                 default:
3843                         ndr_print_bad_level(ndr, name, level);
3844         }
3845 }
3846
3847 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
3848 {
3849         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3850         return NDR_ERR_SUCCESS;
3851 }
3852
3853 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
3854 {
3855         uint32_t v;
3856         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3857         *r = v;
3858         return NDR_ERR_SUCCESS;
3859 }
3860
3861 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_print *ndr, const char *name, uint32_t r)
3862 {
3863         ndr_print_uint32(ndr, name, r);
3864         ndr->depth++;
3865         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION, r);
3866         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_GETCHG_CHECK", DRSUAPI_DS_REPLICA_UPDATE_GETCHG_CHECK, r);
3867         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE, r);
3868         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE", DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE, r);
3869         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE", DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE, r);
3870         ndr->depth--;
3871 }
3872
3873 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3874 {
3875         if (ndr_flags & NDR_SCALARS) {
3876                 NDR_CHECK(ndr_push_align(ndr, 5));
3877                 if (r->naming_context == NULL) {
3878                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3879                 }
3880                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3881                 if (r->dest_dsa_dns_name == NULL) {
3882                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3883                 }
3884                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3885                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3886                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->options));
3887                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3888         }
3889         if (ndr_flags & NDR_BUFFERS) {
3890                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3891                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3892                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3893                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3894                 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));
3895         }
3896         return NDR_ERR_SUCCESS;
3897 }
3898
3899 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3900 {
3901         uint32_t _ptr_naming_context;
3902         TALLOC_CTX *_mem_save_naming_context_0;
3903         uint32_t _ptr_dest_dsa_dns_name;
3904         if (ndr_flags & NDR_SCALARS) {
3905                 NDR_CHECK(ndr_pull_align(ndr, 5));
3906                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3907                 if (_ptr_naming_context) {
3908                         NDR_PULL_ALLOC(ndr, r->naming_context);
3909                 } else {
3910                         r->naming_context = NULL;
3911                 }
3912                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_dest_dsa_dns_name));
3913                 if (_ptr_dest_dsa_dns_name) {
3914                         NDR_PULL_ALLOC(ndr, r->dest_dsa_dns_name);
3915                 } else {
3916                         r->dest_dsa_dns_name = NULL;
3917                 }
3918                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3919                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->options));
3920                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3921         }
3922         if (ndr_flags & NDR_BUFFERS) {
3923                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3924                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3925                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3926                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3927                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
3928                 NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
3929                 if (ndr_get_array_length(ndr, &r->dest_dsa_dns_name) > ndr_get_array_size(ndr, &r->dest_dsa_dns_name)) {
3930                         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));
3931                 }
3932                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t)));
3933                 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));
3934         }
3935         return NDR_ERR_SUCCESS;
3936 }
3937
3938 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3939 {
3940         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefsRequest1");
3941         ndr->depth++;
3942         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3943         ndr->depth++;
3944         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3945         ndr->depth--;
3946         ndr_print_ptr(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3947         ndr->depth++;
3948         ndr_print_string(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3949         ndr->depth--;
3950         ndr_print_GUID(ndr, "dest_dsa_guid", &r->dest_dsa_guid);
3951         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "options", r->options);
3952         ndr->depth--;
3953 }
3954
3955 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3956 {
3957         if (ndr_flags & NDR_SCALARS) {
3958                 int level = ndr_push_get_switch_value(ndr, r);
3959                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3960                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3961                 switch (level) {
3962                         case 1: {
3963                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3964                         break; }
3965
3966                         default:
3967                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3968                 }
3969         }
3970         if (ndr_flags & NDR_BUFFERS) {
3971                 int level = ndr_push_get_switch_value(ndr, r);
3972                 switch (level) {
3973                         case 1:
3974                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3975                         break;
3976
3977                         default:
3978                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3979                 }
3980         }
3981         return NDR_ERR_SUCCESS;
3982 }
3983
3984 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaUpdateRefsRequest *r)
3985 {
3986         int level;
3987         int32_t _level;
3988         level = ndr_pull_get_switch_value(ndr, r);
3989         if (ndr_flags & NDR_SCALARS) {
3990                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3991                 if (_level != level) {
3992                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3993                 }
3994                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3995                 switch (level) {
3996                         case 1: {
3997                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3998                         break; }
3999
4000                         default:
4001                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4002                 }
4003         }
4004         if (ndr_flags & NDR_BUFFERS) {
4005                 switch (level) {
4006                         case 1:
4007                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
4008                         break;
4009
4010                         default:
4011                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4012                 }
4013         }
4014         return NDR_ERR_SUCCESS;
4015 }
4016
4017 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r)
4018 {
4019         int level;
4020         level = ndr_print_get_switch_value(ndr, r);
4021         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaUpdateRefsRequest");
4022         switch (level) {
4023                 case 1:
4024                         ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(ndr, "req1", &r->req1);
4025                 break;
4026
4027                 default:
4028                         ndr_print_bad_level(ndr, name, level);
4029         }
4030 }
4031
4032 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4033 {
4034         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4035         return NDR_ERR_SUCCESS;
4036 }
4037
4038 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4039 {
4040         uint32_t v;
4041         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4042         *r = v;
4043         return NDR_ERR_SUCCESS;
4044 }
4045
4046 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddOptions(struct ndr_print *ndr, const char *name, uint32_t r)
4047 {
4048         ndr_print_uint32(ndr, name, r);
4049         ndr->depth++;
4050         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
4051         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
4052         ndr->depth--;
4053 }
4054
4055 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest1 *r)
4056 {
4057         if (ndr_flags & NDR_SCALARS) {
4058                 NDR_CHECK(ndr_push_align(ndr, 5));
4059                 if (r->naming_context == NULL) {
4060                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4061                 }
4062                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4063                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4064                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4065                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->options));
4066                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4067         }
4068         if (ndr_flags & NDR_BUFFERS) {
4069                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4070                 if (r->source_dsa_address) {
4071                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4072                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4073                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4074                         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));
4075                 }
4076         }
4077         return NDR_ERR_SUCCESS;
4078 }
4079
4080 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest1 *r)
4081 {
4082         uint32_t _ptr_naming_context;
4083         TALLOC_CTX *_mem_save_naming_context_0;
4084         uint32_t _ptr_source_dsa_address;
4085         TALLOC_CTX *_mem_save_source_dsa_address_0;
4086         if (ndr_flags & NDR_SCALARS) {
4087                 NDR_CHECK(ndr_pull_align(ndr, 5));
4088                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4089                 if (_ptr_naming_context) {
4090                         NDR_PULL_ALLOC(ndr, r->naming_context);
4091                 } else {
4092                         r->naming_context = NULL;
4093                 }
4094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4095                 if (_ptr_source_dsa_address) {
4096                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4097                 } else {
4098                         r->source_dsa_address = NULL;
4099                 }
4100                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4101                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options));
4102                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4103         }
4104         if (ndr_flags & NDR_BUFFERS) {
4105                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4106                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4107                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4108                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4109                 if (r->source_dsa_address) {
4110                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4111                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4112                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4113                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4114                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4115                                 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));
4116                         }
4117                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4118                         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));
4119                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4120                 }
4121         }
4122         return NDR_ERR_SUCCESS;
4123 }
4124
4125 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest1 *r)
4126 {
4127         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest1");
4128         ndr->depth++;
4129         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4130         ndr->depth++;
4131         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4132         ndr->depth--;
4133         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4134         ndr->depth++;
4135         if (r->source_dsa_address) {
4136                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4137         }
4138         ndr->depth--;
4139         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4140         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "options", r->options);
4141         ndr->depth--;
4142 }
4143
4144 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest2 *r)
4145 {
4146         if (ndr_flags & NDR_SCALARS) {
4147                 NDR_CHECK(ndr_push_align(ndr, 5));
4148                 if (r->naming_context == NULL) {
4149                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4150                 }
4151                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4152                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_dn));
4153                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_dn));
4154                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4155                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4156                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->options));
4157                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4158         }
4159         if (ndr_flags & NDR_BUFFERS) {
4160                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4161                 if (r->source_dsa_dn) {
4162                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4163                 }
4164                 if (r->transport_dn) {
4165                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4166                 }
4167                 if (r->source_dsa_address) {
4168                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4169                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4170                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4171                         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));
4172                 }
4173         }
4174         return NDR_ERR_SUCCESS;
4175 }
4176
4177 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest2 *r)
4178 {
4179         uint32_t _ptr_naming_context;
4180         TALLOC_CTX *_mem_save_naming_context_0;
4181         uint32_t _ptr_source_dsa_dn;
4182         TALLOC_CTX *_mem_save_source_dsa_dn_0;
4183         uint32_t _ptr_transport_dn;
4184         TALLOC_CTX *_mem_save_transport_dn_0;
4185         uint32_t _ptr_source_dsa_address;
4186         TALLOC_CTX *_mem_save_source_dsa_address_0;
4187         if (ndr_flags & NDR_SCALARS) {
4188                 NDR_CHECK(ndr_pull_align(ndr, 5));
4189                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4190                 if (_ptr_naming_context) {
4191                         NDR_PULL_ALLOC(ndr, r->naming_context);
4192                 } else {
4193                         r->naming_context = NULL;
4194                 }
4195                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_dn));
4196                 if (_ptr_source_dsa_dn) {
4197                         NDR_PULL_ALLOC(ndr, r->source_dsa_dn);
4198                 } else {
4199                         r->source_dsa_dn = NULL;
4200                 }
4201                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_dn));
4202                 if (_ptr_transport_dn) {
4203                         NDR_PULL_ALLOC(ndr, r->transport_dn);
4204                 } else {
4205                         r->transport_dn = NULL;
4206                 }
4207                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4208                 if (_ptr_source_dsa_address) {
4209                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4210                 } else {
4211                         r->source_dsa_address = NULL;
4212                 }
4213                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4214                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options));
4215                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4216         }
4217         if (ndr_flags & NDR_BUFFERS) {
4218                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4219                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4220                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4221                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4222                 if (r->source_dsa_dn) {
4223                         _mem_save_source_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4224                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_dn, 0);
4225                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4226                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_dn_0, 0);
4227                 }
4228                 if (r->transport_dn) {
4229                         _mem_save_transport_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4230                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_dn, 0);
4231                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4232                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_dn_0, 0);
4233                 }
4234                 if (r->source_dsa_address) {
4235                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4236                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4237                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4238                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4239                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4240                                 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));
4241                         }
4242                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4243                         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));
4244                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4245                 }
4246         }
4247         return NDR_ERR_SUCCESS;
4248 }
4249
4250 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest2 *r)
4251 {
4252         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest2");
4253         ndr->depth++;
4254         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4255         ndr->depth++;
4256         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4257         ndr->depth--;
4258         ndr_print_ptr(ndr, "source_dsa_dn", r->source_dsa_dn);
4259         ndr->depth++;
4260         if (r->source_dsa_dn) {
4261                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "source_dsa_dn", r->source_dsa_dn);
4262         }
4263         ndr->depth--;
4264         ndr_print_ptr(ndr, "transport_dn", r->transport_dn);
4265         ndr->depth++;
4266         if (r->transport_dn) {
4267                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "transport_dn", r->transport_dn);
4268         }
4269         ndr->depth--;
4270         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4271         ndr->depth++;
4272         if (r->source_dsa_address) {
4273                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4274         }
4275         ndr->depth--;
4276         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4277         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "options", r->options);
4278         ndr->depth--;
4279 }
4280
4281 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaAddRequest *r)
4282 {
4283         if (ndr_flags & NDR_SCALARS) {
4284                 int level = ndr_push_get_switch_value(ndr, r);
4285                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4286                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4287                 switch (level) {
4288                         case 1: {
4289                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4290                         break; }
4291
4292                         case 2: {
4293                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4294                         break; }
4295
4296                         default:
4297                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4298                 }
4299         }
4300         if (ndr_flags & NDR_BUFFERS) {
4301                 int level = ndr_push_get_switch_value(ndr, r);
4302                 switch (level) {
4303                         case 1:
4304                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4305                         break;
4306
4307                         case 2:
4308                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4309                         break;
4310
4311                         default:
4312                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4313                 }
4314         }
4315         return NDR_ERR_SUCCESS;
4316 }
4317
4318 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaAddRequest *r)
4319 {
4320         int level;
4321         int32_t _level;
4322         level = ndr_pull_get_switch_value(ndr, r);
4323         if (ndr_flags & NDR_SCALARS) {
4324                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4325                 if (_level != level) {
4326                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4327                 }
4328                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4329                 switch (level) {
4330                         case 1: {
4331                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4332                         break; }
4333
4334                         case 2: {
4335                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4336                         break; }
4337
4338                         default:
4339                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4340                 }
4341         }
4342         if (ndr_flags & NDR_BUFFERS) {
4343                 switch (level) {
4344                         case 1:
4345                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4346                         break;
4347
4348                         case 2:
4349                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4350                         break;
4351
4352                         default:
4353                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4354                 }
4355         }
4356         return NDR_ERR_SUCCESS;
4357 }
4358
4359 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaAddRequest *r)
4360 {
4361         int level;
4362         level = ndr_print_get_switch_value(ndr, r);
4363         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaAddRequest");
4364         switch (level) {
4365                 case 1:
4366                         ndr_print_drsuapi_DsReplicaAddRequest1(ndr, "req1", &r->req1);
4367                 break;
4368
4369                 case 2:
4370                         ndr_print_drsuapi_DsReplicaAddRequest2(ndr, "req2", &r->req2);
4371                 break;
4372
4373                 default:
4374                         ndr_print_bad_level(ndr, name, level);
4375         }
4376 }
4377
4378 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDeleteOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4379 {
4380         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4381         return NDR_ERR_SUCCESS;
4382 }
4383
4384 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDeleteOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4385 {
4386         uint32_t v;
4387         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4388         *r = v;
4389         return NDR_ERR_SUCCESS;
4390 }
4391
4392 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDeleteOptions(struct ndr_print *ndr, const char *name, uint32_t r)
4393 {
4394         ndr_print_uint32(ndr, name, r);
4395         ndr->depth++;
4396         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
4397         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
4398         ndr->depth--;
4399 }
4400
4401 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaDelRequest1 *r)
4402 {
4403         if (ndr_flags & NDR_SCALARS) {
4404                 NDR_CHECK(ndr_push_align(ndr, 5));
4405                 if (r->naming_context == NULL) {
4406                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4407                 }
4408                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4409                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4410                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->options));
4411                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4412         }
4413         if (ndr_flags & NDR_BUFFERS) {
4414                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4415                 if (r->source_dsa_address) {
4416                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4417                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4418                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4419                         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));
4420                 }
4421         }
4422         return NDR_ERR_SUCCESS;
4423 }
4424
4425 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaDelRequest1 *r)
4426 {
4427         uint32_t _ptr_naming_context;
4428         TALLOC_CTX *_mem_save_naming_context_0;
4429         uint32_t _ptr_source_dsa_address;
4430         TALLOC_CTX *_mem_save_source_dsa_address_0;
4431         if (ndr_flags & NDR_SCALARS) {
4432                 NDR_CHECK(ndr_pull_align(ndr, 5));
4433                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4434                 if (_ptr_naming_context) {
4435                         NDR_PULL_ALLOC(ndr, r->naming_context);
4436                 } else {
4437                         r->naming_context = NULL;
4438                 }
4439                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4440                 if (_ptr_source_dsa_address) {
4441                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4442                 } else {
4443                         r->source_dsa_address = NULL;
4444                 }
4445                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->options));
4446                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4447         }
4448         if (ndr_flags & NDR_BUFFERS) {
4449                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4450                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4451                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4452                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4453                 if (r->source_dsa_address) {
4454                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4455                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4456                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4457                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4458                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4459                                 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));
4460                         }
4461                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4462                         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));
4463                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4464                 }
4465         }
4466         return NDR_ERR_SUCCESS;
4467 }
4468
4469 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaDelRequest1 *r)
4470 {
4471         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDelRequest1");
4472         ndr->depth++;
4473         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4474         ndr->depth++;
4475         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4476         ndr->depth--;
4477         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4478         ndr->depth++;
4479         if (r->source_dsa_address) {
4480                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4481         }
4482         ndr->depth--;
4483         ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "options", r->options);
4484         ndr->depth--;
4485 }
4486
4487 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaDelRequest *r)
4488 {
4489         if (ndr_flags & NDR_SCALARS) {
4490                 int level = ndr_push_get_switch_value(ndr, r);
4491                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4492                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4493                 switch (level) {
4494                         case 1: {
4495                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4496                         break; }
4497
4498                         default:
4499                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4500                 }
4501         }
4502         if (ndr_flags & NDR_BUFFERS) {
4503                 int level = ndr_push_get_switch_value(ndr, r);
4504                 switch (level) {
4505                         case 1:
4506                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4507                         break;
4508
4509                         default:
4510                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4511                 }
4512         }
4513         return NDR_ERR_SUCCESS;
4514 }
4515
4516 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaDelRequest *r)
4517 {
4518         int level;
4519         int32_t _level;
4520         level = ndr_pull_get_switch_value(ndr, r);
4521         if (ndr_flags & NDR_SCALARS) {
4522                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4523                 if (_level != level) {
4524                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4525                 }
4526                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4527                 switch (level) {
4528                         case 1: {
4529                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4530                         break; }
4531
4532                         default:
4533                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4534                 }
4535         }
4536         if (ndr_flags & NDR_BUFFERS) {
4537                 switch (level) {
4538                         case 1:
4539                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4540                         break;
4541
4542                         default:
4543                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4544                 }
4545         }
4546         return NDR_ERR_SUCCESS;
4547 }
4548
4549 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaDelRequest *r)
4550 {
4551         int level;
4552         level = ndr_print_get_switch_value(ndr, r);
4553         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaDelRequest");
4554         switch (level) {
4555                 case 1:
4556                         ndr_print_drsuapi_DsReplicaDelRequest1(ndr, "req1", &r->req1);
4557                 break;
4558
4559                 default:
4560                         ndr_print_bad_level(ndr, name, level);
4561         }
4562 }
4563
4564 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModifyOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
4565 {
4566         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4567         return NDR_ERR_SUCCESS;
4568 }
4569
4570 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModifyOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
4571 {
4572         uint32_t v;
4573         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4574         *r = v;
4575         return NDR_ERR_SUCCESS;
4576 }
4577
4578 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModifyOptions(struct ndr_print *ndr, const char *name, uint32_t r)
4579 {
4580         ndr_print_uint32(ndr, name, r);
4581         ndr->depth++;
4582         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r);
4583         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r);
4584         ndr->depth--;
4585 }
4586
4587 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaModRequest1 *r)
4588 {
4589         if (ndr_flags & NDR_SCALARS) {
4590                 NDR_CHECK(ndr_push_align(ndr, 5));
4591                 if (r->naming_context == NULL) {
4592                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4593                 }
4594                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4595                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dra));
4596                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dra_address));
4597                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->replica_flags));
4599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->modify_fields));
4600                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->options));
4601                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4602         }
4603         if (ndr_flags & NDR_BUFFERS) {
4604                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4605                 if (r->source_dra_address) {
4606                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4607                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4608                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4609                         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));
4610                 }
4611         }
4612         return NDR_ERR_SUCCESS;
4613 }
4614
4615 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaModRequest1 *r)
4616 {
4617         uint32_t _ptr_naming_context;
4618         TALLOC_CTX *_mem_save_naming_context_0;
4619         uint32_t _ptr_source_dra_address;
4620         TALLOC_CTX *_mem_save_source_dra_address_0;
4621         if (ndr_flags & NDR_SCALARS) {
4622                 NDR_CHECK(ndr_pull_align(ndr, 5));
4623                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4624                 if (_ptr_naming_context) {
4625                         NDR_PULL_ALLOC(ndr, r->naming_context);
4626                 } else {
4627                         r->naming_context = NULL;
4628                 }
4629                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dra));
4630                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dra_address));
4631                 if (_ptr_source_dra_address) {
4632                         NDR_PULL_ALLOC(ndr, r->source_dra_address);
4633                 } else {
4634                         r->source_dra_address = NULL;
4635                 }
4636                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4637                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->replica_flags));
4638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->modify_fields));
4639                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->options));
4640                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4641         }
4642         if (ndr_flags & NDR_BUFFERS) {
4643                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4644                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4645                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4646                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4647                 if (r->source_dra_address) {
4648                         _mem_save_source_dra_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4649                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dra_address, 0);
4650                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dra_address));
4651                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dra_address));
4652                         if (ndr_get_array_length(ndr, &r->source_dra_address) > ndr_get_array_size(ndr, &r->source_dra_address)) {
4653                                 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));
4654                         }
4655                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t)));
4656                         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));
4657                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dra_address_0, 0);
4658                 }
4659         }
4660         return NDR_ERR_SUCCESS;
4661 }
4662
4663 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaModRequest1 *r)
4664 {
4665         ndr_print_struct(ndr, name, "drsuapi_DsReplicaModRequest1");
4666         ndr->depth++;
4667         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4668         ndr->depth++;
4669         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4670         ndr->depth--;
4671         ndr_print_GUID(ndr, "source_dra", &r->source_dra);
4672         ndr_print_ptr(ndr, "source_dra_address", r->source_dra_address);
4673         ndr->depth++;
4674         if (r->source_dra_address) {
4675                 ndr_print_string(ndr, "source_dra_address", r->source_dra_address);
4676         }
4677         ndr->depth--;
4678         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4679         ndr_print_uint32(ndr, "replica_flags", r->replica_flags);
4680         ndr_print_uint32(ndr, "modify_fields", r->modify_fields);
4681         ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "options", r->options);
4682         ndr->depth--;
4683 }
4684
4685 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaModRequest *r)
4686 {
4687         if (ndr_flags & NDR_SCALARS) {
4688                 int level = ndr_push_get_switch_value(ndr, r);
4689                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4690                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4691                 switch (level) {
4692                         case 1: {
4693                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4694                         break; }
4695
4696                         default:
4697                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4698                 }
4699         }
4700         if (ndr_flags & NDR_BUFFERS) {
4701                 int level = ndr_push_get_switch_value(ndr, r);
4702                 switch (level) {
4703                         case 1:
4704                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4705                         break;
4706
4707                         default:
4708                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4709                 }
4710         }
4711         return NDR_ERR_SUCCESS;
4712 }
4713
4714 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaModRequest *r)
4715 {
4716         int level;
4717         int32_t _level;
4718         level = ndr_pull_get_switch_value(ndr, r);
4719         if (ndr_flags & NDR_SCALARS) {
4720                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4721                 if (_level != level) {
4722                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4723                 }
4724                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4725                 switch (level) {
4726                         case 1: {
4727                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4728                         break; }
4729
4730                         default:
4731                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4732                 }
4733         }
4734         if (ndr_flags & NDR_BUFFERS) {
4735                 switch (level) {
4736                         case 1:
4737                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4738                         break;
4739
4740                         default:
4741                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4742                 }
4743         }
4744         return NDR_ERR_SUCCESS;
4745 }
4746
4747 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaModRequest *r)
4748 {
4749         int level;
4750         level = ndr_print_get_switch_value(ndr, r);
4751         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaModRequest");
4752         switch (level) {
4753                 case 1:
4754                         ndr_print_drsuapi_DsReplicaModRequest1(ndr, "req1", &r->req1);
4755                 break;
4756
4757                 default:
4758                         ndr_print_bad_level(ndr, name, level);
4759         }
4760 }
4761
4762 static enum ndr_err_code ndr_push_drsuapi_DsMembershipType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsMembershipType r)
4763 {
4764         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
4765         return NDR_ERR_SUCCESS;
4766 }
4767
4768 static enum ndr_err_code ndr_pull_drsuapi_DsMembershipType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsMembershipType *r)
4769 {
4770         uint32_t v;
4771         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
4772         *r = v;
4773         return NDR_ERR_SUCCESS;
4774 }
4775
4776 _PUBLIC_ void ndr_print_drsuapi_DsMembershipType(struct ndr_print *ndr, const char *name, enum drsuapi_DsMembershipType r)
4777 {
4778         const char *val = NULL;
4779
4780         switch (r) {
4781                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS"; break;
4782                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS"; break;
4783                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS"; break;
4784                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2"; break;
4785                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS"; break;
4786                 case DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS"; break;
4787                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2"; break;
4788         }
4789         ndr_print_enum(ndr, name, "ENUM", val, r);
4790 }
4791
4792 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsCtr1 *r)
4793 {
4794         uint32_t cntr_info_array_1;
4795         uint32_t cntr_group_attrs_1;
4796         uint32_t cntr_sids_1;
4797         if (ndr_flags & NDR_SCALARS) {
4798                 NDR_CHECK(ndr_push_align(ndr, 5));
4799                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
4800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
4801                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
4802                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_attrs));
4804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
4805                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4806         }
4807         if (ndr_flags & NDR_BUFFERS) {
4808                 if (r->info_array) {
4809                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4810                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4811                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4812                         }
4813                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4814                                 if (r->info_array[cntr_info_array_1]) {
4815                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4816                                 }
4817                         }
4818                 }
4819                 if (r->group_attrs) {
4820                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4821                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4822                                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->group_attrs[cntr_group_attrs_1]));
4823                         }
4824                 }
4825                 if (r->sids) {
4826                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_sids));
4827                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4828                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_1]));
4829                         }
4830                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4831                                 if (r->sids[cntr_sids_1]) {
4832                                         NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4833                                 }
4834                         }
4835                 }
4836         }
4837         return NDR_ERR_SUCCESS;
4838 }
4839
4840 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsCtr1 *r)
4841 {
4842         uint32_t _ptr_info_array;
4843         uint32_t cntr_info_array_1;
4844         TALLOC_CTX *_mem_save_info_array_0;
4845         TALLOC_CTX *_mem_save_info_array_1;
4846         TALLOC_CTX *_mem_save_info_array_2;
4847         uint32_t _ptr_group_attrs;
4848         uint32_t cntr_group_attrs_1;
4849         TALLOC_CTX *_mem_save_group_attrs_0;
4850         TALLOC_CTX *_mem_save_group_attrs_1;
4851         uint32_t _ptr_sids;
4852         uint32_t cntr_sids_1;
4853         TALLOC_CTX *_mem_save_sids_0;
4854         TALLOC_CTX *_mem_save_sids_1;
4855         TALLOC_CTX *_mem_save_sids_2;
4856         if (ndr_flags & NDR_SCALARS) {
4857                 NDR_CHECK(ndr_pull_align(ndr, 5));
4858                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
4859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_memberships));
4860                 if (r->num_memberships > 10000) {
4861                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4862                 }
4863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
4864                 if (r->num_sids > 10000) {
4865                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4866                 }
4867                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4868                 if (_ptr_info_array) {
4869                         NDR_PULL_ALLOC(ndr, r->info_array);
4870                 } else {
4871                         r->info_array = NULL;
4872                 }
4873                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_attrs));
4874                 if (_ptr_group_attrs) {
4875                         NDR_PULL_ALLOC(ndr, r->group_attrs);
4876                 } else {
4877                         r->group_attrs = NULL;
4878                 }
4879                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4880                 if (_ptr_sids) {
4881                         NDR_PULL_ALLOC(ndr, r->sids);
4882                 } else {
4883                         r->sids = NULL;
4884                 }
4885                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4886         }
4887         if (ndr_flags & NDR_BUFFERS) {
4888                 if (r->info_array) {
4889                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4890                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4891                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4892                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
4893                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4894                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4895                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4896                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4897                                 if (_ptr_info_array) {
4898                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4899                                 } else {
4900                                         r->info_array[cntr_info_array_1] = NULL;
4901                                 }
4902                         }
4903                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4904                                 if (r->info_array[cntr_info_array_1]) {
4905                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4906                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4907                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4908                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
4909                                 }
4910                         }
4911                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
4912                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
4913                 }
4914                 if (r->group_attrs) {
4915                         _mem_save_group_attrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
4916                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4917                         NDR_CHECK(ndr_pull_array_size(ndr, &r->group_attrs));
4918                         NDR_PULL_ALLOC_N(ndr, r->group_attrs, ndr_get_array_size(ndr, &r->group_attrs));
4919                         _mem_save_group_attrs_1 = NDR_PULL_GET_MEM_CTX(ndr);
4920                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4921                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4922                                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->group_attrs[cntr_group_attrs_1]));
4923                         }
4924                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_1, 0);
4925                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_0, 0);
4926                 }
4927                 if (r->sids) {
4928                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4929                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4930                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4931                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4932                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4933                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4934                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4935                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4936                                 if (_ptr_sids) {
4937                                         NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_1]);
4938                                 } else {
4939                                         r->sids[cntr_sids_1] = NULL;
4940                                 }
4941                         }
4942                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4943                                 if (r->sids[cntr_sids_1]) {
4944                                         _mem_save_sids_2 = NDR_PULL_GET_MEM_CTX(ndr);
4945                                         NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_1], 0);
4946                                         NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4947                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_2, 0);
4948                                 }
4949                         }
4950                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
4951                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
4952                 }
4953                 if (r->info_array) {
4954                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->num_memberships));
4955                 }
4956                 if (r->group_attrs) {
4957                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->group_attrs, r->num_memberships));
4958                 }
4959                 if (r->sids) {
4960                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
4961                 }
4962         }
4963         return NDR_ERR_SUCCESS;
4964 }
4965
4966 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsCtr1 *r)
4967 {
4968         uint32_t cntr_info_array_1;
4969         uint32_t cntr_group_attrs_1;
4970         uint32_t cntr_sids_1;
4971         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsCtr1");
4972         ndr->depth++;
4973         ndr_print_NTSTATUS(ndr, "status", r->status);
4974         ndr_print_uint32(ndr, "num_memberships", r->num_memberships);
4975         ndr_print_uint32(ndr, "num_sids", r->num_sids);
4976         ndr_print_ptr(ndr, "info_array", r->info_array);
4977         ndr->depth++;
4978         if (r->info_array) {
4979                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->num_memberships);
4980                 ndr->depth++;
4981                 for (cntr_info_array_1=0;cntr_info_array_1<r->num_memberships;cntr_info_array_1++) {
4982                         char *idx_1=NULL;
4983                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
4984                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
4985                                 ndr->depth++;
4986                                 if (r->info_array[cntr_info_array_1]) {
4987                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
4988                                 }
4989                                 ndr->depth--;
4990                                 free(idx_1);
4991                         }
4992                 }
4993                 ndr->depth--;
4994         }
4995         ndr->depth--;
4996         ndr_print_ptr(ndr, "group_attrs", r->group_attrs);
4997         ndr->depth++;
4998         if (r->group_attrs) {
4999                 ndr->print(ndr, "%s: ARRAY(%d)", "group_attrs", (int)r->num_memberships);
5000                 ndr->depth++;
5001                 for (cntr_group_attrs_1=0;cntr_group_attrs_1<r->num_memberships;cntr_group_attrs_1++) {
5002                         char *idx_1=NULL;
5003                         if (asprintf(&idx_1, "[%d]", cntr_group_attrs_1) != -1) {
5004                                 ndr_print_samr_GroupAttrs(ndr, "group_attrs", r->group_attrs[cntr_group_attrs_1]);
5005                                 free(idx_1);
5006                         }
5007                 }
5008                 ndr->depth--;
5009         }
5010         ndr->depth--;
5011         ndr_print_ptr(ndr, "sids", r->sids);
5012         ndr->depth++;
5013         if (r->sids) {
5014                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
5015                 ndr->depth++;
5016                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
5017                         char *idx_1=NULL;
5018                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
5019                                 ndr_print_ptr(ndr, "sids", r->sids[cntr_sids_1]);
5020                                 ndr->depth++;
5021                                 if (r->sids[cntr_sids_1]) {
5022                                         ndr_print_dom_sid28(ndr, "sids", r->sids[cntr_sids_1]);
5023                                 }
5024                                 ndr->depth--;
5025                                 free(idx_1);
5026                         }
5027                 }
5028                 ndr->depth--;
5029         }
5030         ndr->depth--;
5031         ndr->depth--;
5032 }
5033
5034 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsCtr *r)
5035 {
5036         if (ndr_flags & NDR_SCALARS) {
5037                 int level = ndr_push_get_switch_value(ndr, r);
5038                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5039                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5040                 switch (level) {
5041                         case 1: {
5042                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
5043                         break; }
5044
5045                         default:
5046                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5047                 }
5048         }
5049         if (ndr_flags & NDR_BUFFERS) {
5050                 int level = ndr_push_get_switch_value(ndr, r);
5051                 switch (level) {
5052                         case 1:
5053                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
5054                         break;
5055
5056                         default:
5057                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5058                 }
5059         }
5060         return NDR_ERR_SUCCESS;
5061 }
5062
5063 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsCtr *r)
5064 {
5065         int level;
5066         int32_t _level;
5067         level = ndr_pull_get_switch_value(ndr, r);
5068         if (ndr_flags & NDR_SCALARS) {
5069                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5070                 if (_level != level) {
5071                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5072                 }
5073                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5074                 switch (level) {
5075                         case 1: {
5076                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
5077                         break; }
5078
5079                         default:
5080                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5081                 }
5082         }
5083         if (ndr_flags & NDR_BUFFERS) {
5084                 switch (level) {
5085                         case 1:
5086                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
5087                         break;
5088
5089                         default:
5090                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5091                 }
5092         }
5093         return NDR_ERR_SUCCESS;
5094 }
5095
5096 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsCtr *r)
5097 {
5098         int level;
5099         level = ndr_print_get_switch_value(ndr, r);
5100         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsCtr");
5101         switch (level) {
5102                 case 1:
5103                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
5104                 break;
5105
5106                 default:
5107                         ndr_print_bad_level(ndr, name, level);
5108         }
5109 }
5110
5111 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsRequest1 *r)
5112 {
5113         uint32_t cntr_info_array_1;
5114         if (ndr_flags & NDR_SCALARS) {
5115                 NDR_CHECK(ndr_push_align(ndr, 5));
5116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5117                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
5118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
5119                 NDR_CHECK(ndr_push_drsuapi_DsMembershipType(ndr, NDR_SCALARS, r->type));
5120                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
5121                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5122         }
5123         if (ndr_flags & NDR_BUFFERS) {
5124                 if (r->info_array) {
5125                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5126                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5127                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
5128                         }
5129                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5130                                 if (r->info_array[cntr_info_array_1]) {
5131                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5132                                 }
5133                         }
5134                 }
5135                 if (r->domain) {
5136                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5137                 }
5138         }
5139         return NDR_ERR_SUCCESS;
5140 }
5141
5142 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsRequest1 *r)
5143 {
5144         uint32_t _ptr_info_array;
5145         uint32_t cntr_info_array_1;
5146         TALLOC_CTX *_mem_save_info_array_0;
5147         TALLOC_CTX *_mem_save_info_array_1;
5148         TALLOC_CTX *_mem_save_info_array_2;
5149         uint32_t _ptr_domain;
5150         TALLOC_CTX *_mem_save_domain_0;
5151         if (ndr_flags & NDR_SCALARS) {
5152                 NDR_CHECK(ndr_pull_align(ndr, 5));
5153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5154                 if (r->count < 1 || r->count > 10000) {
5155                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5156                 }
5157                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5158                 if (_ptr_info_array) {
5159                         NDR_PULL_ALLOC(ndr, r->info_array);
5160                 } else {
5161                         r->info_array = NULL;
5162                 }
5163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
5164                 NDR_CHECK(ndr_pull_drsuapi_DsMembershipType(ndr, NDR_SCALARS, &r->type));
5165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
5166                 if (_ptr_domain) {
5167                         NDR_PULL_ALLOC(ndr, r->domain);
5168                 } else {
5169                         r->domain = NULL;
5170                 }
5171                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5172         }
5173         if (ndr_flags & NDR_BUFFERS) {
5174                 if (r->info_array) {
5175                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5176                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5177                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
5178                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
5179                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5180                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5181                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5182                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5183                                 if (_ptr_info_array) {
5184                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
5185                                 } else {
5186                                         r->info_array[cntr_info_array_1] = NULL;
5187                                 }
5188                         }
5189                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5190                                 if (r->info_array[cntr_info_array_1]) {
5191                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
5192                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
5193                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5194                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
5195                                 }
5196                         }
5197                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
5198                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
5199                 }
5200                 if (r->domain) {
5201                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
5202                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
5203                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5204                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
5205                 }
5206                 if (r->info_array) {
5207                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->count));
5208                 }
5209         }
5210         return NDR_ERR_SUCCESS;
5211 }
5212
5213 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsRequest1 *r)
5214 {
5215         uint32_t cntr_info_array_1;
5216         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsRequest1");
5217         ndr->depth++;
5218         ndr_print_uint32(ndr, "count", r->count);
5219         ndr_print_ptr(ndr, "info_array", r->info_array);
5220         ndr->depth++;
5221         if (r->info_array) {
5222                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->count);
5223                 ndr->depth++;
5224                 for (cntr_info_array_1=0;cntr_info_array_1<r->count;cntr_info_array_1++) {
5225                         char *idx_1=NULL;
5226                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
5227                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
5228                                 ndr->depth++;
5229                                 if (r->info_array[cntr_info_array_1]) {
5230                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
5231                                 }
5232                                 ndr->depth--;
5233                                 free(idx_1);
5234                         }
5235                 }
5236                 ndr->depth--;
5237         }
5238         ndr->depth--;
5239         ndr_print_uint32(ndr, "flags", r->flags);
5240         ndr_print_drsuapi_DsMembershipType(ndr, "type", r->type);
5241         ndr_print_ptr(ndr, "domain", r->domain);
5242         ndr->depth++;
5243         if (r->domain) {
5244                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "domain", r->domain);
5245         }
5246         ndr->depth--;
5247         ndr->depth--;
5248 }
5249
5250 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsRequest *r)
5251 {
5252         if (ndr_flags & NDR_SCALARS) {
5253                 int level = ndr_push_get_switch_value(ndr, r);
5254                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5255                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5256                 switch (level) {
5257                         case 1: {
5258                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5259                         break; }
5260
5261                         default:
5262                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5263                 }
5264         }
5265         if (ndr_flags & NDR_BUFFERS) {
5266                 int level = ndr_push_get_switch_value(ndr, r);
5267                 switch (level) {
5268                         case 1:
5269                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5270                         break;
5271
5272                         default:
5273                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5274                 }
5275         }
5276         return NDR_ERR_SUCCESS;
5277 }
5278
5279 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsRequest *r)
5280 {
5281         int level;
5282         int32_t _level;
5283         level = ndr_pull_get_switch_value(ndr, r);
5284         if (ndr_flags & NDR_SCALARS) {
5285                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5286                 if (_level != level) {
5287                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5288                 }
5289                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5290                 switch (level) {
5291                         case 1: {
5292                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5293                         break; }
5294
5295                         default:
5296                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5297                 }
5298         }
5299         if (ndr_flags & NDR_BUFFERS) {
5300                 switch (level) {
5301                         case 1:
5302                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5303                         break;
5304
5305                         default:
5306                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5307                 }
5308         }
5309         return NDR_ERR_SUCCESS;
5310 }
5311
5312 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsRequest *r)
5313 {
5314         int level;
5315         level = ndr_print_get_switch_value(ndr, r);
5316         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsRequest");
5317         switch (level) {
5318                 case 1:
5319                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req1", &r->req1);
5320                 break;
5321
5322                 default:
5323                         ndr_print_bad_level(ndr, name, level);
5324         }
5325 }
5326
5327 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5328 {
5329         if (ndr_flags & NDR_SCALARS) {
5330                 NDR_CHECK(ndr_push_align(ndr, 5));
5331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
5332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
5333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
5334                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
5335                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5336         }
5337         if (ndr_flags & NDR_BUFFERS) {
5338                 if (r->data) {
5339                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
5340                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
5341                 }
5342         }
5343         return NDR_ERR_SUCCESS;
5344 }
5345
5346 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5347 {
5348         uint32_t _ptr_data;
5349         TALLOC_CTX *_mem_save_data_0;
5350         if (ndr_flags & NDR_SCALARS) {
5351                 NDR_CHECK(ndr_pull_align(ndr, 5));
5352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
5353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
5354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
5355                 if (r->length > 0x00A00000) {
5356                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5357                 }
5358                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
5359                 if (_ptr_data) {
5360                         NDR_PULL_ALLOC(ndr, r->data);
5361                 } else {
5362                         r->data = NULL;
5363                 }
5364                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5365         }
5366         if (ndr_flags & NDR_BUFFERS) {
5367                 if (r->data) {
5368                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5369                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
5370                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
5371                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
5372                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
5373                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
5374                 }
5375                 if (r->data) {
5376                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
5377                 }
5378         }
5379         return NDR_ERR_SUCCESS;
5380 }
5381
5382 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5383 {
5384         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogRequest1");
5385         ndr->depth++;
5386         ndr_print_uint32(ndr, "unknown1", r->unknown1);
5387         ndr_print_uint32(ndr, "unknown2", r->unknown2);
5388         ndr_print_uint32(ndr, "length", r->length);
5389         ndr_print_ptr(ndr, "data", r->data);
5390         ndr->depth++;
5391         if (r->data) {
5392                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
5393         }
5394         ndr->depth--;
5395         ndr->depth--;
5396 }
5397
5398 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5399 {
5400         if (ndr_flags & NDR_SCALARS) {
5401                 int level = ndr_push_get_switch_value(ndr, r);
5402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5403                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5404                 switch (level) {
5405                         case 1: {
5406                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5407                         break; }
5408
5409                         default:
5410                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5411                 }
5412         }
5413         if (ndr_flags & NDR_BUFFERS) {
5414                 int level = ndr_push_get_switch_value(ndr, r);
5415                 switch (level) {
5416                         case 1:
5417                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5418                         break;
5419
5420                         default:
5421                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5422                 }
5423         }
5424         return NDR_ERR_SUCCESS;
5425 }
5426
5427 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogRequest *r)
5428 {
5429         int level;
5430         uint32_t _level;
5431         level = ndr_pull_get_switch_value(ndr, r);
5432         if (ndr_flags & NDR_SCALARS) {
5433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5434                 if (_level != level) {
5435                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5436                 }
5437                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5438                 switch (level) {
5439                         case 1: {
5440                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5441                         break; }
5442
5443                         default:
5444                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5445                 }
5446         }
5447         if (ndr_flags & NDR_BUFFERS) {
5448                 switch (level) {
5449                         case 1:
5450                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5451                         break;
5452
5453                         default:
5454                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5455                 }
5456         }
5457         return NDR_ERR_SUCCESS;
5458 }
5459
5460 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5461 {
5462         int level;
5463         level = ndr_print_get_switch_value(ndr, r);
5464         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogRequest");
5465         switch (level) {
5466                 case 1:
5467                         ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(ndr, "req1", &r->req1);
5468                 break;
5469
5470                 default:
5471                         ndr_print_bad_level(ndr, name, level);
5472         }
5473 }
5474
5475 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5476 {
5477         if (ndr_flags & NDR_SCALARS) {
5478                 NDR_CHECK(ndr_push_align(ndr, 8));
5479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
5480                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
5481                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5482                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time2));
5483                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5484                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time4));
5485                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5486                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time6));
5487                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
5488                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data1));
5489                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data2));
5490                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5491         }
5492         if (ndr_flags & NDR_BUFFERS) {
5493                 if (r->data1) {
5494                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length1));
5495                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data1, r->length1));
5496                 }
5497                 if (r->data2) {
5498                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length2));
5499                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data2, r->length2));
5500                 }
5501         }
5502         return NDR_ERR_SUCCESS;
5503 }
5504
5505 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5506 {
5507         uint32_t _ptr_data1;
5508         TALLOC_CTX *_mem_save_data1_0;
5509         uint32_t _ptr_data2;
5510         TALLOC_CTX *_mem_save_data2_0;
5511         if (ndr_flags & NDR_SCALARS) {
5512                 NDR_CHECK(ndr_pull_align(ndr, 8));
5513                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length1));
5514                 if (r->length1 > 0x00A00000) {
5515                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5516                 }
5517                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length2));
5518                 if (r->length2 > 0x00A00000) {
5519                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5520                 }
5521                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5522                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time2));
5523                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5524                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time4));
5525                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5526                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time6));
5527                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
5528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data1));
5529                 if (_ptr_data1) {
5530                         NDR_PULL_ALLOC(ndr, r->data1);
5531                 } else {
5532                         r->data1 = NULL;
5533                 }
5534                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data2));
5535                 if (_ptr_data2) {
5536                         NDR_PULL_ALLOC(ndr, r->data2);
5537                 } else {
5538                         r->data2 = NULL;
5539                 }
5540                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5541         }
5542         if (ndr_flags & NDR_BUFFERS) {
5543                 if (r->data1) {
5544                         _mem_save_data1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5545                         NDR_PULL_SET_MEM_CTX(ndr, r->data1, 0);
5546                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data1));
5547                         NDR_PULL_ALLOC_N(ndr, r->data1, ndr_get_array_size(ndr, &r->data1));
5548                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data1, ndr_get_array_size(ndr, &r->data1)));
5549                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data1_0, 0);
5550                 }
5551                 if (r->data2) {
5552                         _mem_save_data2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5553                         NDR_PULL_SET_MEM_CTX(ndr, r->data2, 0);
5554                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data2));
5555                         NDR_PULL_ALLOC_N(ndr, r->data2, ndr_get_array_size(ndr, &r->data2));
5556                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data2, ndr_get_array_size(ndr, &r->data2)));
5557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data2_0, 0);
5558                 }
5559                 if (r->data1) {
5560                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data1, r->length1));
5561                 }
5562                 if (r->data2) {
5563                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data2, r->length2));
5564                 }
5565         }
5566         return NDR_ERR_SUCCESS;
5567 }
5568
5569 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5570 {
5571         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogInfo1");
5572         ndr->depth++;
5573         ndr_print_uint32(ndr, "length1", r->length1);
5574         ndr_print_uint32(ndr, "length2", r->length2);
5575         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5576         ndr_print_NTTIME(ndr, "time2", r->time2);
5577         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5578         ndr_print_NTTIME(ndr, "time4", r->time4);
5579         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5580         ndr_print_NTTIME(ndr, "time6", r->time6);
5581         ndr_print_NTSTATUS(ndr, "status", r->status);
5582         ndr_print_ptr(ndr, "data1", r->data1);
5583         ndr->depth++;
5584         if (r->data1) {
5585                 ndr_print_array_uint8(ndr, "data1", r->data1, r->length1);
5586         }
5587         ndr->depth--;
5588         ndr_print_ptr(ndr, "data2", r->data2);
5589         ndr->depth++;
5590         if (r->data2) {
5591                 ndr_print_array_uint8(ndr, "data2", r->data2, r->length2);
5592         }
5593         ndr->depth--;
5594         ndr->depth--;
5595 }
5596
5597 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5598 {
5599         if (ndr_flags & NDR_SCALARS) {
5600                 int level = ndr_push_get_switch_value(ndr, r);
5601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5602                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5603                 switch (level) {
5604                         case 1: {
5605                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5606                         break; }
5607
5608                         default:
5609                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5610                 }
5611         }
5612         if (ndr_flags & NDR_BUFFERS) {
5613                 int level = ndr_push_get_switch_value(ndr, r);
5614                 switch (level) {
5615                         case 1:
5616                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5617                         break;
5618
5619                         default:
5620                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5621                 }
5622         }
5623         return NDR_ERR_SUCCESS;
5624 }
5625
5626 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogInfo *r)
5627 {
5628         int level;
5629         uint32_t _level;
5630         level = ndr_pull_get_switch_value(ndr, r);
5631         if (ndr_flags & NDR_SCALARS) {
5632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5633                 if (_level != level) {
5634                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5635                 }
5636                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5637                 switch (level) {
5638                         case 1: {
5639                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5640                         break; }
5641
5642                         default:
5643                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5644                 }
5645         }
5646         if (ndr_flags & NDR_BUFFERS) {
5647                 switch (level) {
5648                         case 1:
5649                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5650                         break;
5651
5652                         default:
5653                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5654                 }
5655         }
5656         return NDR_ERR_SUCCESS;
5657 }
5658
5659 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5660 {
5661         int level;
5662         level = ndr_print_get_switch_value(ndr, r);
5663         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogInfo");
5664         switch (level) {
5665                 case 1:
5666                         ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(ndr, "info1", &r->info1);
5667                 break;
5668
5669                 default:
5670                         ndr_print_bad_level(ndr, name, level);
5671         }
5672 }
5673
5674 static enum ndr_err_code ndr_push_drsuapi_DsNameStatus(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameStatus r)
5675 {
5676         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5677         return NDR_ERR_SUCCESS;
5678 }
5679
5680 static enum ndr_err_code ndr_pull_drsuapi_DsNameStatus(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameStatus *r)
5681 {
5682         uint32_t v;
5683         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5684         *r = v;
5685         return NDR_ERR_SUCCESS;
5686 }
5687
5688 _PUBLIC_ void ndr_print_drsuapi_DsNameStatus(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameStatus r)
5689 {
5690         const char *val = NULL;
5691
5692         switch (r) {
5693                 case DRSUAPI_DS_NAME_STATUS_OK: val = "DRSUAPI_DS_NAME_STATUS_OK"; break;
5694                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR: val = "DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR"; break;
5695                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND: val = "DRSUAPI_DS_NAME_STATUS_NOT_FOUND"; break;
5696                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE: val = "DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE"; break;
5697                 case DRSUAPI_DS_NAME_STATUS_NO_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_MAPPING"; break;
5698                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY: val = "DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY"; break;
5699                 case DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING"; break;
5700                 case DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL"; break;
5701         }
5702         ndr_print_enum(ndr, name, "ENUM", val, r);
5703 }
5704
5705 static enum ndr_err_code ndr_push_drsuapi_DsNameFlags(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFlags r)
5706 {
5707         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5708         return NDR_ERR_SUCCESS;
5709 }
5710
5711 static enum ndr_err_code ndr_pull_drsuapi_DsNameFlags(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFlags *r)
5712 {
5713         uint32_t v;
5714         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5715         *r = v;
5716         return NDR_ERR_SUCCESS;
5717 }
5718
5719 _PUBLIC_ void ndr_print_drsuapi_DsNameFlags(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFlags r)
5720 {
5721         const char *val = NULL;
5722
5723         switch (r) {
5724                 case DRSUAPI_DS_NAME_FLAG_NO_FLAGS: val = "DRSUAPI_DS_NAME_FLAG_NO_FLAGS"; break;
5725                 case DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY: val = "DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY"; break;
5726                 case DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC: val = "DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC"; break;
5727                 case DRSUAPI_DS_NAME_FLAG_GCVERIFY: val = "DRSUAPI_DS_NAME_FLAG_GCVERIFY"; break;
5728                 case DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL"; break;
5729         }
5730         ndr_print_enum(ndr, name, "ENUM", val, r);
5731 }
5732
5733 static enum ndr_err_code ndr_push_drsuapi_DsNameFormat(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFormat r)
5734 {
5735         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5736         return NDR_ERR_SUCCESS;
5737 }
5738
5739 static enum ndr_err_code ndr_pull_drsuapi_DsNameFormat(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFormat *r)
5740 {
5741         uint32_t v;
5742         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5743         *r = v;
5744         return NDR_ERR_SUCCESS;
5745 }
5746
5747 _PUBLIC_ void ndr_print_drsuapi_DsNameFormat(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFormat r)
5748 {
5749         const char *val = NULL;
5750
5751         switch (r) {
5752                 case DRSUAPI_DS_NAME_FORMAT_UNKNOWN: val = "DRSUAPI_DS_NAME_FORMAT_UNKNOWN"; break;
5753                 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: val = "DRSUAPI_DS_NAME_FORMAT_FQDN_1779"; break;
5754                 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: val = "DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT"; break;
5755                 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: val = "DRSUAPI_DS_NAME_FORMAT_DISPLAY"; break;
5756                 case DRSUAPI_DS_NAME_FORMAT_GUID: val = "DRSUAPI_DS_NAME_FORMAT_GUID"; break;
5757                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL"; break;
5758                 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL"; break;
5759                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX"; break;
5760                 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL"; break;
5761                 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: val = "DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY"; break;
5762                 case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: val = "DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN"; break;
5763         }
5764         ndr_print_enum(ndr, name, "ENUM", val, r);
5765 }
5766
5767 static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameString *r)
5768 {
5769         if (ndr_flags & NDR_SCALARS) {
5770                 NDR_CHECK(ndr_push_align(ndr, 5));
5771                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
5772                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5773         }
5774         if (ndr_flags & NDR_BUFFERS) {
5775                 if (r->str) {
5776                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5777                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5778                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5779                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str, ndr_charset_length(r->str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5780                 }
5781         }
5782         return NDR_ERR_SUCCESS;
5783 }
5784
5785 static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameString *r)
5786 {
5787         uint32_t _ptr_str;
5788         TALLOC_CTX *_mem_save_str_0;
5789         if (ndr_flags & NDR_SCALARS) {
5790                 NDR_CHECK(ndr_pull_align(ndr, 5));
5791                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
5792                 if (_ptr_str) {
5793                         NDR_PULL_ALLOC(ndr, r->str);
5794                 } else {
5795                         r->str = NULL;
5796                 }
5797                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5798         }
5799         if (ndr_flags & NDR_BUFFERS) {
5800                 if (r->str) {
5801                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
5802                         NDR_PULL_SET_MEM_CTX(ndr, r->str, 0);
5803                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str));
5804                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str));
5805                         if (ndr_get_array_length(ndr, &r->str) > ndr_get_array_size(ndr, &r->str)) {
5806                                 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));
5807                         }
5808                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t)));
5809                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t), CH_UTF16));
5810                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
5811                 }
5812         }
5813         return NDR_ERR_SUCCESS;
5814 }
5815
5816 _PUBLIC_ void ndr_print_drsuapi_DsNameString(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameString *r)
5817 {
5818         ndr_print_struct(ndr, name, "drsuapi_DsNameString");
5819         ndr->depth++;
5820         ndr_print_ptr(ndr, "str", r->str);
5821         ndr->depth++;
5822         if (r->str) {
5823                 ndr_print_string(ndr, "str", r->str);
5824         }
5825         ndr->depth--;
5826         ndr->depth--;
5827 }
5828
5829 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameRequest1 *r)
5830 {
5831         uint32_t cntr_names_1;
5832         if (ndr_flags & NDR_SCALARS) {
5833                 NDR_CHECK(ndr_push_align(ndr, 5));
5834                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->codepage));
5835                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->language));
5836                 NDR_CHECK(ndr_push_drsuapi_DsNameFlags(ndr, NDR_SCALARS, r->format_flags));
5837                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_offered));
5838                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
5839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5840                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
5841                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5842         }
5843         if (ndr_flags & NDR_BUFFERS) {
5844                 if (r->names) {
5845                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5846                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5847                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5848                         }
5849                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5850                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5851                         }
5852                 }
5853         }
5854         return NDR_ERR_SUCCESS;
5855 }
5856
5857 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameRequest1 *r)
5858 {
5859         uint32_t _ptr_names;
5860         uint32_t cntr_names_1;
5861         TALLOC_CTX *_mem_save_names_0;
5862         TALLOC_CTX *_mem_save_names_1;
5863         if (ndr_flags & NDR_SCALARS) {
5864                 NDR_CHECK(ndr_pull_align(ndr, 5));
5865                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->codepage));
5866                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->language));
5867                 NDR_CHECK(ndr_pull_drsuapi_DsNameFlags(ndr, NDR_SCALARS, &r->format_flags));
5868                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_offered));
5869                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_desired));
5870                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5871                 if (r->count < 1 || r->count > 10000) {
5872                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5873                 }
5874                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
5875                 if (_ptr_names) {
5876                         NDR_PULL_ALLOC(ndr, r->names);
5877                 } else {
5878                         r->names = NULL;
5879                 }
5880                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5881         }
5882         if (ndr_flags & NDR_BUFFERS) {
5883                 if (r->names) {
5884                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5885                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5886                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
5887                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
5888                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
5889                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5890                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5891                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5892                         }
5893                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5894                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5895                         }
5896                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
5897                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
5898                 }
5899                 if (r->names) {
5900                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
5901                 }
5902         }
5903         return NDR_ERR_SUCCESS;
5904 }
5905
5906 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameRequest1 *r)
5907 {
5908         uint32_t cntr_names_1;
5909         ndr_print_struct(ndr, name, "drsuapi_DsNameRequest1");
5910         ndr->depth++;
5911         ndr_print_uint32(ndr, "codepage", r->codepage);
5912         ndr_print_uint32(ndr, "language", r->language);
5913         ndr_print_drsuapi_DsNameFlags(ndr, "format_flags", r->format_flags);
5914         ndr_print_drsuapi_DsNameFormat(ndr, "format_offered", r->format_offered);
5915         ndr_print_drsuapi_DsNameFormat(ndr, "format_desired", r->format_desired);
5916         ndr_print_uint32(ndr, "count", r->count);
5917         ndr_print_ptr(ndr, "names", r->names);
5918         ndr->depth++;
5919         if (r->names) {
5920                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
5921                 ndr->depth++;
5922                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
5923                         char *idx_1=NULL;
5924                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
5925                                 ndr_print_drsuapi_DsNameString(ndr, "names", &r->names[cntr_names_1]);
5926                                 free(idx_1);
5927                         }
5928                 }
5929                 ndr->depth--;
5930         }
5931         ndr->depth--;
5932         ndr->depth--;
5933 }
5934
5935 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameRequest *r)
5936 {
5937         if (ndr_flags & NDR_SCALARS) {
5938                 int level = ndr_push_get_switch_value(ndr, r);
5939                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5940                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5941                 switch (level) {
5942                         case 1: {
5943                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5944                         break; }
5945
5946                         default:
5947                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5948                 }
5949         }
5950         if (ndr_flags & NDR_BUFFERS) {
5951                 int level = ndr_push_get_switch_value(ndr, r);
5952                 switch (level) {
5953                         case 1:
5954                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5955                         break;
5956
5957                         default:
5958                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5959                 }
5960         }
5961         return NDR_ERR_SUCCESS;
5962 }
5963
5964 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameRequest *r)
5965 {
5966         int level;
5967         int32_t _level;
5968         level = ndr_pull_get_switch_value(ndr, r);
5969         if (ndr_flags & NDR_SCALARS) {
5970                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5971                 if (_level != level) {
5972                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5973                 }
5974                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5975                 switch (level) {
5976                         case 1: {
5977                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5978                         break; }
5979
5980                         default:
5981                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5982                 }
5983         }
5984         if (ndr_flags & NDR_BUFFERS) {
5985                 switch (level) {
5986                         case 1:
5987                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5988                         break;
5989
5990                         default:
5991                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5992                 }
5993         }
5994         return NDR_ERR_SUCCESS;
5995 }
5996
5997 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameRequest *r)
5998 {
5999         int level;
6000         level = ndr_print_get_switch_value(ndr, r);
6001         ndr_print_union(ndr, name, level, "drsuapi_DsNameRequest");
6002         switch (level) {
6003                 case 1:
6004                         ndr_print_drsuapi_DsNameRequest1(ndr, "req1", &r->req1);
6005                 break;
6006
6007                 default:
6008                         ndr_print_bad_level(ndr, name, level);
6009         }
6010 }
6011
6012 static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameInfo1 *r)
6013 {
6014         if (ndr_flags & NDR_SCALARS) {
6015                 NDR_CHECK(ndr_push_align(ndr, 5));
6016                 NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
6017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
6018                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
6019                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6020         }
6021         if (ndr_flags & NDR_BUFFERS) {
6022                 if (r->dns_domain_name) {
6023                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
6024                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6025                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
6026                         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));
6027                 }
6028                 if (r->result_name) {
6029                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
6030                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6031                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
6032                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->result_name, ndr_charset_length(r->result_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6033                 }
6034         }
6035         return NDR_ERR_SUCCESS;
6036 }
6037
6038 static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameInfo1 *r)
6039 {
6040         uint32_t _ptr_dns_domain_name;
6041         TALLOC_CTX *_mem_save_dns_domain_name_0;
6042         uint32_t _ptr_result_name;
6043         TALLOC_CTX *_mem_save_result_name_0;
6044         if (ndr_flags & NDR_SCALARS) {
6045                 NDR_CHECK(ndr_pull_align(ndr, 5));
6046                 NDR_CHECK(ndr_pull_drsuapi_DsNameStatus(ndr, NDR_SCALARS, &r->status));
6047                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain_name));
6048                 if (_ptr_dns_domain_name) {
6049                         NDR_PULL_ALLOC(ndr, r->dns_domain_name);
6050                 } else {
6051                         r->dns_domain_name = NULL;
6052                 }
6053                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_result_name));
6054                 if (_ptr_result_name) {
6055                         NDR_PULL_ALLOC(ndr, r->result_name);
6056                 } else {
6057                         r->result_name = NULL;
6058                 }
6059                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6060         }
6061         if (ndr_flags & NDR_BUFFERS) {
6062                 if (r->dns_domain_name) {
6063                         _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6064                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
6065                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain_name));
6066                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain_name));
6067                         if (ndr_get_array_length(ndr, &r->dns_domain_name) > ndr_get_array_size(ndr, &r->dns_domain_name)) {
6068                                 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));
6069                         }
6070                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t)));
6071                         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));
6072                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
6073                 }
6074                 if (r->result_name) {
6075                         _mem_save_result_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6076                         NDR_PULL_SET_MEM_CTX(ndr, r->result_name, 0);
6077                         NDR_CHECK(ndr_pull_array_size(ndr, &r->result_name));
6078                         NDR_CHECK(ndr_pull_array_length(ndr, &r->result_name));
6079                         if (ndr_get_array_length(ndr, &r->result_name) > ndr_get_array_size(ndr, &r->result_name)) {
6080                                 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));
6081                         }
6082                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t)));
6083                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t), CH_UTF16));
6084                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_result_name_0, 0);
6085                 }
6086         }
6087         return NDR_ERR_SUCCESS;
6088 }
6089
6090 _PUBLIC_ void ndr_print_drsuapi_DsNameInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameInfo1 *r)
6091 {
6092         ndr_print_struct(ndr, name, "drsuapi_DsNameInfo1");
6093         ndr->depth++;
6094         ndr_print_drsuapi_DsNameStatus(ndr, "status", r->status);
6095         ndr_print_ptr(ndr, "dns_domain_name", r->dns_domain_name);
6096         ndr->depth++;
6097         if (r->dns_domain_name) {
6098                 ndr_print_string(ndr, "dns_domain_name", r->dns_domain_name);
6099         }
6100         ndr->depth--;
6101         ndr_print_ptr(ndr, "result_name", r->result_name);
6102         ndr->depth++;
6103         if (r->result_name) {
6104                 ndr_print_string(ndr, "result_name", r->result_name);
6105         }
6106         ndr->depth--;
6107         ndr->depth--;
6108 }
6109
6110 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameCtr1 *r)
6111 {
6112         uint32_t cntr_array_1;
6113         if (ndr_flags & NDR_SCALARS) {
6114                 NDR_CHECK(ndr_push_align(ndr, 5));
6115                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
6117                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6118         }
6119         if (ndr_flags & NDR_BUFFERS) {
6120                 if (r->array) {
6121                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6122                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6123                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6124                         }
6125                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6126                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6127                         }
6128                 }
6129         }
6130         return NDR_ERR_SUCCESS;
6131 }
6132
6133 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameCtr1 *r)
6134 {
6135         uint32_t _ptr_array;
6136         uint32_t cntr_array_1;
6137         TALLOC_CTX *_mem_save_array_0;
6138         TALLOC_CTX *_mem_save_array_1;
6139         if (ndr_flags & NDR_SCALARS) {
6140                 NDR_CHECK(ndr_pull_align(ndr, 5));
6141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6142                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
6143                 if (_ptr_array) {
6144                         NDR_PULL_ALLOC(ndr, r->array);
6145                 } else {
6146                         r->array = NULL;
6147                 }
6148                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6149         }
6150         if (ndr_flags & NDR_BUFFERS) {
6151                 if (r->array) {
6152                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6153                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6154                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
6155                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
6156                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
6157                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6158                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6159                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6160                         }
6161                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6162                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6163                         }
6164                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
6165                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
6166                 }
6167                 if (r->array) {
6168                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
6169                 }
6170         }
6171         return NDR_ERR_SUCCESS;
6172 }
6173
6174 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameCtr1 *r)
6175 {
6176         uint32_t cntr_array_1;
6177         ndr_print_struct(ndr, name, "drsuapi_DsNameCtr1");
6178         ndr->depth++;
6179         ndr_print_uint32(ndr, "count", r->count);
6180         ndr_print_ptr(ndr, "array", r->array);
6181         ndr->depth++;
6182         if (r->array) {
6183                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
6184                 ndr->depth++;
6185                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
6186                         char *idx_1=NULL;
6187                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
6188                                 ndr_print_drsuapi_DsNameInfo1(ndr, "array", &r->array[cntr_array_1]);
6189                                 free(idx_1);
6190                         }
6191                 }
6192                 ndr->depth--;
6193         }
6194         ndr->depth--;
6195         ndr->depth--;
6196 }
6197
6198 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameCtr *r)
6199 {
6200         if (ndr_flags & NDR_SCALARS) {
6201                 int level = ndr_push_get_switch_value(ndr, r);
6202                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6203                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6204                 switch (level) {
6205                         case 1: {
6206                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
6207                         break; }
6208
6209                         default:
6210                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6211                 }
6212         }
6213         if (ndr_flags & NDR_BUFFERS) {
6214                 int level = ndr_push_get_switch_value(ndr, r);
6215                 switch (level) {
6216                         case 1:
6217                                 if (r->ctr1) {
6218                                         NDR_CHECK(ndr_push_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6219                                 }
6220                         break;
6221
6222                         default:
6223                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6224                 }
6225         }
6226         return NDR_ERR_SUCCESS;
6227 }
6228
6229 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameCtr *r)
6230 {
6231         int level;
6232         int32_t _level;
6233         TALLOC_CTX *_mem_save_ctr1_0;
6234         level = ndr_pull_get_switch_value(ndr, r);
6235         if (ndr_flags & NDR_SCALARS) {
6236                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6237                 if (_level != level) {
6238                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6239                 }
6240                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6241                 switch (level) {
6242                         case 1: {
6243                                 uint32_t _ptr_ctr1;
6244                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
6245                                 if (_ptr_ctr1) {
6246                                         NDR_PULL_ALLOC(ndr, r->ctr1);
6247                                 } else {
6248                                         r->ctr1 = NULL;
6249                                 }
6250                         break; }
6251
6252                         default:
6253                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6254                 }
6255         }
6256         if (ndr_flags & NDR_BUFFERS) {
6257                 switch (level) {
6258                         case 1:
6259                                 if (r->ctr1) {
6260                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6261                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
6262                                         NDR_CHECK(ndr_pull_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6263                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
6264                                 }
6265                         break;
6266
6267                         default:
6268                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6269                 }
6270         }
6271         return NDR_ERR_SUCCESS;
6272 }
6273
6274 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameCtr *r)
6275 {
6276         int level;
6277         level = ndr_print_get_switch_value(ndr, r);
6278         ndr_print_union(ndr, name, level, "drsuapi_DsNameCtr");
6279         switch (level) {
6280                 case 1:
6281                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
6282                         ndr->depth++;
6283                         if (r->ctr1) {
6284                                 ndr_print_drsuapi_DsNameCtr1(ndr, "ctr1", r->ctr1);
6285                         }
6286                         ndr->depth--;
6287                 break;
6288
6289                 default:
6290                         ndr_print_bad_level(ndr, name, level);
6291         }
6292 }
6293
6294 static enum ndr_err_code ndr_push_drsuapi_DsSpnOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsSpnOperation r)
6295 {
6296         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6297         return NDR_ERR_SUCCESS;
6298 }
6299
6300 static enum ndr_err_code ndr_pull_drsuapi_DsSpnOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsSpnOperation *r)
6301 {
6302         uint32_t v;
6303         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6304         *r = v;
6305         return NDR_ERR_SUCCESS;
6306 }
6307
6308 _PUBLIC_ void ndr_print_drsuapi_DsSpnOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsSpnOperation r)
6309 {
6310         const char *val = NULL;
6311
6312         switch (r) {
6313                 case DRSUAPI_DS_SPN_OPERATION_ADD: val = "DRSUAPI_DS_SPN_OPERATION_ADD"; break;
6314                 case DRSUAPI_DS_SPN_OPERATION_REPLACE: val = "DRSUAPI_DS_SPN_OPERATION_REPLACE"; break;
6315                 case DRSUAPI_DS_SPN_OPERATION_DELETE: val = "DRSUAPI_DS_SPN_OPERATION_DELETE"; break;
6316         }
6317         ndr_print_enum(ndr, name, "ENUM", val, r);
6318 }
6319
6320 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6321 {
6322         uint32_t cntr_spn_names_1;
6323         if (ndr_flags & NDR_SCALARS) {
6324                 NDR_CHECK(ndr_push_align(ndr, 5));
6325                 NDR_CHECK(ndr_push_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, r->operation));
6326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
6327                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
6328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6329                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
6330                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6331         }
6332         if (ndr_flags & NDR_BUFFERS) {
6333                 if (r->object_dn) {
6334                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6335                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6336                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6337                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6338                 }
6339                 if (r->spn_names) {
6340                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6341                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6342                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6343                         }
6344                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6345                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6346                         }
6347                 }
6348         }
6349         return NDR_ERR_SUCCESS;
6350 }
6351
6352 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnRequest1 *r)
6353 {
6354         uint32_t _ptr_object_dn;
6355         TALLOC_CTX *_mem_save_object_dn_0;
6356         uint32_t _ptr_spn_names;
6357         uint32_t cntr_spn_names_1;
6358         TALLOC_CTX *_mem_save_spn_names_0;
6359         TALLOC_CTX *_mem_save_spn_names_1;
6360         if (ndr_flags & NDR_SCALARS) {
6361                 NDR_CHECK(ndr_pull_align(ndr, 5));
6362                 NDR_CHECK(ndr_pull_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, &r->operation));
6363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
6364                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
6365                 if (_ptr_object_dn) {
6366                         NDR_PULL_ALLOC(ndr, r->object_dn);
6367                 } else {
6368                         r->object_dn = NULL;
6369                 }
6370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6371                 if (r->count > 10000) {
6372                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6373                 }
6374                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_spn_names));
6375                 if (_ptr_spn_names) {
6376                         NDR_PULL_ALLOC(ndr, r->spn_names);
6377                 } else {
6378                         r->spn_names = NULL;
6379                 }
6380                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6381         }
6382         if (ndr_flags & NDR_BUFFERS) {
6383                 if (r->object_dn) {
6384                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6385                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
6386                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
6387                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
6388                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
6389                                 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));
6390                         }
6391                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
6392                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
6393                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
6394                 }
6395                 if (r->spn_names) {
6396                         _mem_save_spn_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6397                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6398                         NDR_CHECK(ndr_pull_array_size(ndr, &r->spn_names));
6399                         NDR_PULL_ALLOC_N(ndr, r->spn_names, ndr_get_array_size(ndr, &r->spn_names));
6400                         _mem_save_spn_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
6401                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6402                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6403                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6404                         }
6405                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6406                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6407                         }
6408                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_1, 0);
6409                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_0, 0);
6410                 }
6411                 if (r->spn_names) {
6412                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->spn_names, r->count));
6413                 }
6414         }
6415         return NDR_ERR_SUCCESS;
6416 }
6417
6418 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6419 {
6420         uint32_t cntr_spn_names_1;
6421         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnRequest1");
6422         ndr->depth++;
6423         ndr_print_drsuapi_DsSpnOperation(ndr, "operation", r->operation);
6424         ndr_print_uint32(ndr, "unknown1", r->unknown1);
6425         ndr_print_ptr(ndr, "object_dn", r->object_dn);
6426         ndr->depth++;
6427         if (r->object_dn) {
6428                 ndr_print_string(ndr, "object_dn", r->object_dn);
6429         }
6430         ndr->depth--;
6431         ndr_print_uint32(ndr, "count", r->count);
6432         ndr_print_ptr(ndr, "spn_names", r->spn_names);
6433         ndr->depth++;
6434         if (r->spn_names) {
6435                 ndr->print(ndr, "%s: ARRAY(%d)", "spn_names", (int)r->count);
6436                 ndr->depth++;
6437                 for (cntr_spn_names_1=0;cntr_spn_names_1<r->count;cntr_spn_names_1++) {
6438                         char *idx_1=NULL;
6439                         if (asprintf(&idx_1, "[%d]", cntr_spn_names_1) != -1) {
6440                                 ndr_print_drsuapi_DsNameString(ndr, "spn_names", &r->spn_names[cntr_spn_names_1]);
6441                                 free(idx_1);
6442                         }
6443                 }
6444                 ndr->depth--;
6445         }
6446         ndr->depth--;
6447         ndr->depth--;
6448 }
6449
6450 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnRequest *r)
6451 {
6452         if (ndr_flags & NDR_SCALARS) {
6453                 int level = ndr_push_get_switch_value(ndr, r);
6454                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6455                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6456                 switch (level) {
6457                         case 1: {
6458                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6459                         break; }
6460
6461                         default:
6462                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6463                 }
6464         }
6465         if (ndr_flags & NDR_BUFFERS) {
6466                 int level = ndr_push_get_switch_value(ndr, r);
6467                 switch (level) {
6468                         case 1:
6469                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6470                         break;
6471
6472                         default:
6473                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6474                 }
6475         }
6476         return NDR_ERR_SUCCESS;
6477 }
6478
6479 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnRequest *r)
6480 {
6481         int level;
6482         int32_t _level;
6483         level = ndr_pull_get_switch_value(ndr, r);
6484         if (ndr_flags & NDR_SCALARS) {
6485                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6486                 if (_level != level) {
6487                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6488                 }
6489                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6490                 switch (level) {
6491                         case 1: {
6492                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6493                         break; }
6494
6495                         default:
6496                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6497                 }
6498         }
6499         if (ndr_flags & NDR_BUFFERS) {
6500                 switch (level) {
6501                         case 1:
6502                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6503                         break;
6504
6505                         default:
6506                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6507                 }
6508         }
6509         return NDR_ERR_SUCCESS;
6510 }
6511
6512 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnRequest *r)
6513 {
6514         int level;
6515         level = ndr_print_get_switch_value(ndr, r);
6516         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnRequest");
6517         switch (level) {
6518                 case 1:
6519                         ndr_print_drsuapi_DsWriteAccountSpnRequest1(ndr, "req1", &r->req1);
6520                 break;
6521
6522                 default:
6523                         ndr_print_bad_level(ndr, name, level);
6524         }
6525 }
6526
6527 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6528 {
6529         if (ndr_flags & NDR_SCALARS) {
6530                 NDR_CHECK(ndr_push_align(ndr, 4));
6531                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
6532                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6533         }
6534         if (ndr_flags & NDR_BUFFERS) {
6535         }
6536         return NDR_ERR_SUCCESS;
6537 }
6538
6539 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnResult1 *r)
6540 {
6541         if (ndr_flags & NDR_SCALARS) {
6542                 NDR_CHECK(ndr_pull_align(ndr, 4));
6543                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
6544                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6545         }
6546         if (ndr_flags & NDR_BUFFERS) {
6547         }
6548         return NDR_ERR_SUCCESS;
6549 }
6550
6551 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6552 {
6553         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnResult1");
6554         ndr->depth++;
6555         ndr_print_WERROR(ndr, "status", r->status);
6556         ndr->depth--;
6557 }
6558
6559 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnResult *r)
6560 {
6561         if (ndr_flags & NDR_SCALARS) {
6562                 int level = ndr_push_get_switch_value(ndr, r);
6563                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6564                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6565                 switch (level) {
6566                         case 1: {
6567                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6568                         break; }
6569
6570                         default:
6571                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6572                 }
6573         }
6574         if (ndr_flags & NDR_BUFFERS) {
6575                 int level = ndr_push_get_switch_value(ndr, r);
6576                 switch (level) {
6577                         case 1:
6578                         break;
6579
6580                         default:
6581                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6582                 }
6583         }
6584         return NDR_ERR_SUCCESS;
6585 }
6586
6587 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnResult *r)
6588 {
6589         int level;
6590         int32_t _level;
6591         level = ndr_pull_get_switch_value(ndr, r);
6592         if (ndr_flags & NDR_SCALARS) {
6593                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6594                 if (_level != level) {
6595                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6596                 }
6597                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6598                 switch (level) {
6599                         case 1: {
6600                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6601                         break; }
6602
6603                         default:
6604                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6605                 }
6606         }
6607         if (ndr_flags & NDR_BUFFERS) {
6608                 switch (level) {
6609                         case 1:
6610                         break;
6611
6612                         default:
6613                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6614                 }
6615         }
6616         return NDR_ERR_SUCCESS;
6617 }
6618
6619 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnResult *r)
6620 {
6621         int level;
6622         level = ndr_print_get_switch_value(ndr, r);
6623         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnResult");
6624         switch (level) {
6625                 case 1:
6626                         ndr_print_drsuapi_DsWriteAccountSpnResult1(ndr, "res1", &r->res1);
6627                 break;
6628
6629                 default:
6630                         ndr_print_bad_level(ndr, name, level);
6631         }
6632 }
6633
6634 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6635 {
6636         if (ndr_flags & NDR_SCALARS) {
6637                 NDR_CHECK(ndr_push_align(ndr, 5));
6638                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6639                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
6640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->commit));
6641                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6642         }
6643         if (ndr_flags & NDR_BUFFERS) {
6644                 if (r->server_dn) {
6645                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6646                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6647                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6648                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6649                 }
6650                 if (r->domain_dn) {
6651                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6652                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6653                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6654                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_dn, ndr_charset_length(r->domain_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6655                 }
6656         }
6657         return NDR_ERR_SUCCESS;
6658 }
6659
6660 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerRequest1 *r)
6661 {
6662         uint32_t _ptr_server_dn;
6663         TALLOC_CTX *_mem_save_server_dn_0;
6664         uint32_t _ptr_domain_dn;
6665         TALLOC_CTX *_mem_save_domain_dn_0;
6666         if (ndr_flags & NDR_SCALARS) {
6667                 NDR_CHECK(ndr_pull_align(ndr, 5));
6668                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6669                 if (_ptr_server_dn) {
6670                         NDR_PULL_ALLOC(ndr, r->server_dn);
6671                 } else {
6672                         r->server_dn = NULL;
6673                 }
6674                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_dn));
6675                 if (_ptr_domain_dn) {
6676                         NDR_PULL_ALLOC(ndr, r->domain_dn);
6677                 } else {
6678                         r->domain_dn = NULL;
6679                 }
6680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->commit));
6681                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6682         }
6683         if (ndr_flags & NDR_BUFFERS) {
6684                 if (r->server_dn) {
6685                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6686                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6687                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6688                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6689                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6690                                 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));
6691                         }
6692                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6693                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6694                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6695                 }
6696                 if (r->domain_dn) {
6697                         _mem_save_domain_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6698                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_dn, 0);
6699                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_dn));
6700                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_dn));
6701                         if (ndr_get_array_length(ndr, &r->domain_dn) > ndr_get_array_size(ndr, &r->domain_dn)) {
6702                                 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));
6703                         }
6704                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t)));
6705                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t), CH_UTF16));
6706                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_dn_0, 0);
6707                 }
6708         }
6709         return NDR_ERR_SUCCESS;
6710 }
6711
6712 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6713 {
6714         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerRequest1");
6715         ndr->depth++;
6716         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6717         ndr->depth++;
6718         if (r->server_dn) {
6719                 ndr_print_string(ndr, "server_dn", r->server_dn);
6720         }
6721         ndr->depth--;
6722         ndr_print_ptr(ndr, "domain_dn", r->domain_dn);
6723         ndr->depth++;
6724         if (r->domain_dn) {
6725                 ndr_print_string(ndr, "domain_dn", r->domain_dn);
6726         }
6727         ndr->depth--;
6728         ndr_print_uint32(ndr, "commit", r->commit);
6729         ndr->depth--;
6730 }
6731
6732 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerRequest *r)
6733 {
6734         if (ndr_flags & NDR_SCALARS) {
6735                 int level = ndr_push_get_switch_value(ndr, r);
6736                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6737                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6738                 switch (level) {
6739                         case 1: {
6740                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6741                         break; }
6742
6743                         default:
6744                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6745                 }
6746         }
6747         if (ndr_flags & NDR_BUFFERS) {
6748                 int level = ndr_push_get_switch_value(ndr, r);
6749                 switch (level) {
6750                         case 1:
6751                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6752                         break;
6753
6754                         default:
6755                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6756                 }
6757         }
6758         return NDR_ERR_SUCCESS;
6759 }
6760
6761 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerRequest *r)
6762 {
6763         int level;
6764         int32_t _level;
6765         level = ndr_pull_get_switch_value(ndr, r);
6766         if (ndr_flags & NDR_SCALARS) {
6767                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6768                 if (_level != level) {
6769                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6770                 }
6771                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6772                 switch (level) {
6773                         case 1: {
6774                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6775                         break; }
6776
6777                         default:
6778                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6779                 }
6780         }
6781         if (ndr_flags & NDR_BUFFERS) {
6782                 switch (level) {
6783                         case 1:
6784                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6785                         break;
6786
6787                         default:
6788                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6789                 }
6790         }
6791         return NDR_ERR_SUCCESS;
6792 }
6793
6794 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerRequest *r)
6795 {
6796         int level;
6797         level = ndr_print_get_switch_value(ndr, r);
6798         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerRequest");
6799         switch (level) {
6800                 case 1:
6801                         ndr_print_drsuapi_DsRemoveDSServerRequest1(ndr, "req1", &r->req1);
6802                 break;
6803
6804                 default:
6805                         ndr_print_bad_level(ndr, name, level);
6806         }
6807 }
6808
6809 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerResult1 *r)
6810 {
6811         if (ndr_flags & NDR_SCALARS) {
6812                 NDR_CHECK(ndr_push_align(ndr, 4));
6813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->last_dc_in_domain));
6814                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6815         }
6816         if (ndr_flags & NDR_BUFFERS) {
6817         }
6818         return NDR_ERR_SUCCESS;
6819 }
6820
6821 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerResult1 *r)
6822 {
6823         if (ndr_flags & NDR_SCALARS) {
6824                 NDR_CHECK(ndr_pull_align(ndr, 4));
6825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->last_dc_in_domain));
6826                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6827         }
6828         if (ndr_flags & NDR_BUFFERS) {
6829         }
6830         return NDR_ERR_SUCCESS;
6831 }
6832
6833 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerResult1 *r)
6834 {
6835         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerResult1");
6836         ndr->depth++;
6837         ndr_print_uint32(ndr, "last_dc_in_domain", r->last_dc_in_domain);
6838         ndr->depth--;
6839 }
6840
6841 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerResult *r)
6842 {
6843         if (ndr_flags & NDR_SCALARS) {
6844                 int level = ndr_push_get_switch_value(ndr, r);
6845                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6846                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6847                 switch (level) {
6848                         case 1: {
6849                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6850                         break; }
6851
6852                         default:
6853                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6854                 }
6855         }
6856         if (ndr_flags & NDR_BUFFERS) {
6857                 int level = ndr_push_get_switch_value(ndr, r);
6858                 switch (level) {
6859                         case 1:
6860                         break;
6861
6862                         default:
6863                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6864                 }
6865         }
6866         return NDR_ERR_SUCCESS;
6867 }
6868
6869 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerResult *r)
6870 {
6871         int level;
6872         int32_t _level;
6873         level = ndr_pull_get_switch_value(ndr, r);
6874         if (ndr_flags & NDR_SCALARS) {
6875                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6876                 if (_level != level) {
6877                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6878                 }
6879                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6880                 switch (level) {
6881                         case 1: {
6882                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6883                         break; }
6884
6885                         default:
6886                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6887                 }
6888         }
6889         if (ndr_flags & NDR_BUFFERS) {
6890                 switch (level) {
6891                         case 1:
6892                         break;
6893
6894                         default:
6895                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6896                 }
6897         }
6898         return NDR_ERR_SUCCESS;
6899 }
6900
6901 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerResult *r)
6902 {
6903         int level;
6904         level = ndr_print_get_switch_value(ndr, r);
6905         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerResult");
6906         switch (level) {
6907                 case 1:
6908                         ndr_print_drsuapi_DsRemoveDSServerResult1(ndr, "res1", &r->res1);
6909                 break;
6910
6911                 default:
6912                         ndr_print_bad_level(ndr, name, level);
6913         }
6914 }
6915
6916 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoRequest1 *r)
6917 {
6918         if (ndr_flags & NDR_SCALARS) {
6919                 NDR_CHECK(ndr_push_align(ndr, 5));
6920                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
6921                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
6922                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6923         }
6924         if (ndr_flags & NDR_BUFFERS) {
6925                 if (r->domain_name) {
6926                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6927                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6928                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6929                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6930                 }
6931         }
6932         return NDR_ERR_SUCCESS;
6933 }
6934
6935 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoRequest1 *r)
6936 {
6937         uint32_t _ptr_domain_name;
6938         TALLOC_CTX *_mem_save_domain_name_0;
6939         if (ndr_flags & NDR_SCALARS) {
6940                 NDR_CHECK(ndr_pull_align(ndr, 5));
6941                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
6942                 if (_ptr_domain_name) {
6943                         NDR_PULL_ALLOC(ndr, r->domain_name);
6944                 } else {
6945                         r->domain_name = NULL;
6946                 }
6947                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
6948                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6949         }
6950         if (ndr_flags & NDR_BUFFERS) {
6951                 if (r->domain_name) {
6952                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6953                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
6954                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
6955                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
6956                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
6957                                 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));
6958                         }
6959                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
6960                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
6961                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
6962                 }
6963         }
6964         return NDR_ERR_SUCCESS;
6965 }
6966
6967 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoRequest1 *r)
6968 {
6969         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoRequest1");
6970         ndr->depth++;
6971         ndr_print_ptr(ndr, "domain_name", r->domain_name);
6972         ndr->depth++;
6973         if (r->domain_name) {
6974                 ndr_print_string(ndr, "domain_name", r->domain_name);
6975         }
6976         ndr->depth--;
6977         ndr_print_int32(ndr, "level", r->level);
6978         ndr->depth--;
6979 }
6980
6981 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoRequest *r)
6982 {
6983         if (ndr_flags & NDR_SCALARS) {
6984                 int level = ndr_push_get_switch_value(ndr, r);
6985                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6986                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6987                 switch (level) {
6988                         case 1: {
6989                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6990                         break; }
6991
6992                         default:
6993                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6994                 }
6995         }
6996         if (ndr_flags & NDR_BUFFERS) {
6997                 int level = ndr_push_get_switch_value(ndr, r);
6998                 switch (level) {
6999                         case 1:
7000                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
7001                         break;
7002
7003                         default:
7004                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
7005                 }
7006         }
7007         return NDR_ERR_SUCCESS;
7008 }
7009
7010 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoRequest *r)
7011 {
7012         int level;
7013         int32_t _level;
7014         level = ndr_pull_get_switch_value(ndr, r);
7015         if (ndr_flags & NDR_SCALARS) {
7016                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
7017                 if (_level != level) {
7018                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
7019                 }
7020                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
7021                 switch (level) {
7022                         case 1: {
7023                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
7024                         break; }
7025
7026                         default:
7027                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
7028                 }
7029         }
7030         if (ndr_flags & NDR_BUFFERS) {
7031                 switch (level) {
7032                         case 1:
7033                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
7034                         break;
7035
7036                         default:
7037                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
7038                 }
7039         }
7040         return NDR_ERR_SUCCESS;
7041 }
7042
7043 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoRequest *r)
7044 {
7045         int level;
7046         level = ndr_print_get_switch_value(ndr, r);
7047         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoRequest");
7048         switch (level) {
7049                 case 1:
7050                         ndr_print_drsuapi_DsGetDCInfoRequest1(ndr, "req1", &r->req1);
7051                 break;
7052
7053                 default:
7054                         ndr_print_bad_level(ndr, name, level);
7055         }
7056 }
7057
7058 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo1 *r)
7059 {
7060         if (ndr_flags & NDR_SCALARS) {
7061                 NDR_CHECK(ndr_push_align(ndr, 5));
7062                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7063                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7064                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7065                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7066                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7069                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7070         }
7071         if (ndr_flags & NDR_BUFFERS) {
7072                 if (r->netbios_name) {
7073                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7074                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7075                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7076                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7077                 }
7078                 if (r->dns_name) {
7079                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7080                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7081                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7082                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7083                 }
7084                 if (r->site_name) {
7085                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7086                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7087                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7088                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7089                 }
7090                 if (r->computer_dn) {
7091                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7092                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7093                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7094                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7095                 }
7096                 if (r->server_dn) {
7097                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7098                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7099                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7100                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7101                 }
7102         }
7103         return NDR_ERR_SUCCESS;
7104 }
7105
7106 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo1 *r)
7107 {
7108         uint32_t _ptr_netbios_name;
7109         TALLOC_CTX *_mem_save_netbios_name_0;
7110         uint32_t _ptr_dns_name;
7111         TALLOC_CTX *_mem_save_dns_name_0;
7112         uint32_t _ptr_site_name;
7113         TALLOC_CTX *_mem_save_site_name_0;
7114         uint32_t _ptr_computer_dn;
7115         TALLOC_CTX *_mem_save_computer_dn_0;
7116         uint32_t _ptr_server_dn;
7117         TALLOC_CTX *_mem_save_server_dn_0;
7118         if (ndr_flags & NDR_SCALARS) {
7119                 NDR_CHECK(ndr_pull_align(ndr, 5));
7120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7121                 if (_ptr_netbios_name) {
7122                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7123                 } else {
7124                         r->netbios_name = NULL;
7125                 }
7126                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7127                 if (_ptr_dns_name) {
7128                         NDR_PULL_ALLOC(ndr, r->dns_name);
7129                 } else {
7130                         r->dns_name = NULL;
7131                 }
7132                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7133                 if (_ptr_site_name) {
7134                         NDR_PULL_ALLOC(ndr, r->site_name);
7135                 } else {
7136                         r->site_name = NULL;
7137                 }
7138                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7139                 if (_ptr_computer_dn) {
7140                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7141                 } else {
7142                         r->computer_dn = NULL;
7143                 }
7144                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7145                 if (_ptr_server_dn) {
7146                         NDR_PULL_ALLOC(ndr, r->server_dn);
7147                 } else {
7148                         r->server_dn = NULL;
7149                 }
7150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7152                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7153         }
7154         if (ndr_flags & NDR_BUFFERS) {
7155                 if (r->netbios_name) {
7156                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7157                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7158                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7159                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7160                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7161                                 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));
7162                         }
7163                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7164                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7165                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7166                 }
7167                 if (r->dns_name) {
7168                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7169                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7170                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7171                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7172                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7173                                 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));
7174                         }
7175                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7176                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7177                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7178                 }
7179                 if (r->site_name) {
7180                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7181                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7182                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7183                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7184                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7185                                 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));
7186                         }
7187                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7188                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7189                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7190                 }
7191                 if (r->computer_dn) {
7192                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7193                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7194                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7195                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7196                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7197                                 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));
7198                         }
7199                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7200                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7201                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7202                 }
7203                 if (r->server_dn) {
7204                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7205                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7206                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7207                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7208                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7209                                 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));
7210                         }
7211                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7212                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7213                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7214                 }
7215         }
7216         return NDR_ERR_SUCCESS;
7217 }
7218
7219 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo1 *r)
7220 {
7221         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo1");
7222         ndr->depth++;
7223         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7224         ndr->depth++;
7225         if (r->netbios_name) {
7226                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7227         }
7228         ndr->depth--;
7229         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7230         ndr->depth++;
7231         if (r->dns_name) {
7232                 ndr_print_string(ndr, "dns_name", r->dns_name);
7233         }
7234         ndr->depth--;
7235         ndr_print_ptr(ndr, "site_name", r->site_name);
7236         ndr->depth++;
7237         if (r->site_name) {
7238                 ndr_print_string(ndr, "site_name", r->site_name);
7239         }
7240         ndr->depth--;
7241         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7242         ndr->depth++;
7243         if (r->computer_dn) {
7244                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7245         }
7246         ndr->depth--;
7247         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7248         ndr->depth++;
7249         if (r->server_dn) {
7250                 ndr_print_string(ndr, "server_dn", r->server_dn);
7251         }
7252         ndr->depth--;
7253         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7254         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7255         ndr->depth--;
7256 }
7257
7258 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr1 *r)
7259 {
7260         uint32_t cntr_array_1;
7261         if (ndr_flags & NDR_SCALARS) {
7262                 NDR_CHECK(ndr_push_align(ndr, 5));
7263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7264                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7265                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7266         }
7267         if (ndr_flags & NDR_BUFFERS) {
7268                 if (r->array) {
7269                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7270                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7271                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7272                         }
7273                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7274                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7275                         }
7276                 }
7277         }
7278         return NDR_ERR_SUCCESS;
7279 }
7280
7281 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr1 *r)
7282 {
7283         uint32_t _ptr_array;
7284         uint32_t cntr_array_1;
7285         TALLOC_CTX *_mem_save_array_0;
7286         TALLOC_CTX *_mem_save_array_1;
7287         if (ndr_flags & NDR_SCALARS) {
7288                 NDR_CHECK(ndr_pull_align(ndr, 5));
7289                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7290                 if (r->count > 10000) {
7291                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7292                 }
7293                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7294                 if (_ptr_array) {
7295                         NDR_PULL_ALLOC(ndr, r->array);
7296                 } else {
7297                         r->array = NULL;
7298                 }
7299                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7300         }
7301         if (ndr_flags & NDR_BUFFERS) {
7302                 if (r->array) {
7303                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7304                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7305                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7306                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7307                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7308                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7309                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7310                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7311                         }
7312                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7313                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7314                         }
7315                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7316                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7317                 }
7318                 if (r->array) {
7319                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7320                 }
7321         }
7322         return NDR_ERR_SUCCESS;
7323 }
7324
7325 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr1 *r)
7326 {
7327         uint32_t cntr_array_1;
7328         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr1");
7329         ndr->depth++;
7330         ndr_print_uint32(ndr, "count", r->count);
7331         ndr_print_ptr(ndr, "array", r->array);
7332         ndr->depth++;
7333         if (r->array) {
7334                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7335                 ndr->depth++;
7336                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7337                         char *idx_1=NULL;
7338                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7339                                 ndr_print_drsuapi_DsGetDCInfo1(ndr, "array", &r->array[cntr_array_1]);
7340                                 free(idx_1);
7341                         }
7342                 }
7343                 ndr->depth--;
7344         }
7345         ndr->depth--;
7346         ndr->depth--;
7347 }
7348
7349 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo2 *r)
7350 {
7351         if (ndr_flags & NDR_SCALARS) {
7352                 NDR_CHECK(ndr_push_align(ndr, 5));
7353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7355                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7361                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7363                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7364                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7365                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7366                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7367                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7368         }
7369         if (ndr_flags & NDR_BUFFERS) {
7370                 if (r->netbios_name) {
7371                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7372                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7373                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7374                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7375                 }
7376                 if (r->dns_name) {
7377                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7378                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7379                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7380                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7381                 }
7382                 if (r->site_name) {
7383                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7384                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7385                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7386                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7387                 }
7388                 if (r->site_dn) {
7389                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7390                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7391                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7392                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7393                 }
7394                 if (r->computer_dn) {
7395                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7396                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7397                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7398                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7399                 }
7400                 if (r->server_dn) {
7401                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7402                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7403                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7404                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7405                 }
7406                 if (r->ntds_dn) {
7407                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7408                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7409                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7410                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7411                 }
7412         }
7413         return NDR_ERR_SUCCESS;
7414 }
7415
7416 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo2 *r)
7417 {
7418         uint32_t _ptr_netbios_name;
7419         TALLOC_CTX *_mem_save_netbios_name_0;
7420         uint32_t _ptr_dns_name;
7421         TALLOC_CTX *_mem_save_dns_name_0;
7422         uint32_t _ptr_site_name;
7423         TALLOC_CTX *_mem_save_site_name_0;
7424         uint32_t _ptr_site_dn;
7425         TALLOC_CTX *_mem_save_site_dn_0;
7426         uint32_t _ptr_computer_dn;
7427         TALLOC_CTX *_mem_save_computer_dn_0;
7428         uint32_t _ptr_server_dn;
7429         TALLOC_CTX *_mem_save_server_dn_0;
7430         uint32_t _ptr_ntds_dn;
7431         TALLOC_CTX *_mem_save_ntds_dn_0;
7432         if (ndr_flags & NDR_SCALARS) {
7433                 NDR_CHECK(ndr_pull_align(ndr, 5));
7434                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7435                 if (_ptr_netbios_name) {
7436                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7437                 } else {
7438                         r->netbios_name = NULL;
7439                 }
7440                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7441                 if (_ptr_dns_name) {
7442                         NDR_PULL_ALLOC(ndr, r->dns_name);
7443                 } else {
7444                         r->dns_name = NULL;
7445                 }
7446                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7447                 if (_ptr_site_name) {
7448                         NDR_PULL_ALLOC(ndr, r->site_name);
7449                 } else {
7450                         r->site_name = NULL;
7451                 }
7452                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7453                 if (_ptr_site_dn) {
7454                         NDR_PULL_ALLOC(ndr, r->site_dn);
7455                 } else {
7456                         r->site_dn = NULL;
7457                 }
7458                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7459                 if (_ptr_computer_dn) {
7460                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7461                 } else {
7462                         r->computer_dn = NULL;
7463                 }
7464                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7465                 if (_ptr_server_dn) {
7466                         NDR_PULL_ALLOC(ndr, r->server_dn);
7467                 } else {
7468                         r->server_dn = NULL;
7469                 }
7470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7471                 if (_ptr_ntds_dn) {
7472                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7473                 } else {
7474                         r->ntds_dn = NULL;
7475                 }
7476                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7477                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7479                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7480                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7481                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7482                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7483                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7484         }
7485         if (ndr_flags & NDR_BUFFERS) {
7486                 if (r->netbios_name) {
7487                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7488                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7489                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7490                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7491                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7492                                 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));
7493                         }
7494                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7495                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7496                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7497                 }
7498                 if (r->dns_name) {
7499                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7500                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7501                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7502                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7503                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7504                                 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));
7505                         }
7506                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7507                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7508                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7509                 }
7510                 if (r->site_name) {
7511                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7512                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7513                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7514                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7515                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7516                                 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));
7517                         }
7518                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7519                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7520                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7521                 }
7522                 if (r->site_dn) {
7523                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7524                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7525                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7526                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7527                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7528                                 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));
7529                         }
7530                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7531                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7532                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7533                 }
7534                 if (r->computer_dn) {
7535                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7536                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7537                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7538                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7539                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7540                                 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));
7541                         }
7542                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7543                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7544                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7545                 }
7546                 if (r->server_dn) {
7547                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7548                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7549                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7550                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7551                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7552                                 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));
7553                         }
7554                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7555                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7556                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7557                 }
7558                 if (r->ntds_dn) {
7559                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7560                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7561                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7562                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7563                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7564                                 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));
7565                         }
7566                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7567                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7568                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7569                 }
7570         }
7571         return NDR_ERR_SUCCESS;
7572 }
7573
7574 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo2 *r)
7575 {
7576         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo2");
7577         ndr->depth++;
7578         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7579         ndr->depth++;
7580         if (r->netbios_name) {
7581                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7582         }
7583         ndr->depth--;
7584         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7585         ndr->depth++;
7586         if (r->dns_name) {
7587                 ndr_print_string(ndr, "dns_name", r->dns_name);
7588         }
7589         ndr->depth--;
7590         ndr_print_ptr(ndr, "site_name", r->site_name);
7591         ndr->depth++;
7592         if (r->site_name) {
7593                 ndr_print_string(ndr, "site_name", r->site_name);
7594         }
7595         ndr->depth--;
7596         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7597         ndr->depth++;
7598         if (r->site_dn) {
7599                 ndr_print_string(ndr, "site_dn", r->site_dn);
7600         }
7601         ndr->depth--;
7602         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7603         ndr->depth++;
7604         if (r->computer_dn) {
7605                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7606         }
7607         ndr->depth--;
7608         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7609         ndr->depth++;
7610         if (r->server_dn) {
7611                 ndr_print_string(ndr, "server_dn", r->server_dn);
7612         }
7613         ndr->depth--;
7614         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7615         ndr->depth++;
7616         if (r->ntds_dn) {
7617                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7618         }
7619         ndr->depth--;
7620         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7621         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7622         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7623         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7624         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7625         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7626         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7627         ndr->depth--;
7628 }
7629
7630 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr2 *r)
7631 {
7632         uint32_t cntr_array_1;
7633         if (ndr_flags & NDR_SCALARS) {
7634                 NDR_CHECK(ndr_push_align(ndr, 5));
7635                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7636                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7637                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7638         }
7639         if (ndr_flags & NDR_BUFFERS) {
7640                 if (r->array) {
7641                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7642                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7643                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7644                         }
7645                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7646                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7647                         }
7648                 }
7649         }
7650         return NDR_ERR_SUCCESS;
7651 }
7652
7653 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr2 *r)
7654 {
7655         uint32_t _ptr_array;
7656         uint32_t cntr_array_1;
7657         TALLOC_CTX *_mem_save_array_0;
7658         TALLOC_CTX *_mem_save_array_1;
7659         if (ndr_flags & NDR_SCALARS) {
7660                 NDR_CHECK(ndr_pull_align(ndr, 5));
7661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7662                 if (r->count > 10000) {
7663                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7664                 }
7665                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7666                 if (_ptr_array) {
7667                         NDR_PULL_ALLOC(ndr, r->array);
7668                 } else {
7669                         r->array = NULL;
7670                 }
7671                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7672         }
7673         if (ndr_flags & NDR_BUFFERS) {
7674                 if (r->array) {
7675                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7676                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7677                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7678                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7679                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7680                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7681                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7682                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7683                         }
7684                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7685                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7686                         }
7687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7688                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7689                 }
7690                 if (r->array) {
7691                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7692                 }
7693         }
7694         return NDR_ERR_SUCCESS;
7695 }
7696
7697 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr2 *r)
7698 {
7699         uint32_t cntr_array_1;
7700         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr2");
7701         ndr->depth++;
7702         ndr_print_uint32(ndr, "count", r->count);
7703         ndr_print_ptr(ndr, "array", r->array);
7704         ndr->depth++;
7705         if (r->array) {
7706                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7707                 ndr->depth++;
7708                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7709                         char *idx_1=NULL;
7710                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7711                                 ndr_print_drsuapi_DsGetDCInfo2(ndr, "array", &r->array[cntr_array_1]);
7712                                 free(idx_1);
7713                         }
7714                 }
7715                 ndr->depth--;
7716         }
7717         ndr->depth--;
7718         ndr->depth--;
7719 }
7720
7721 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo3 *r)
7722 {
7723         if (ndr_flags & NDR_SCALARS) {
7724                 NDR_CHECK(ndr_push_align(ndr, 5));
7725                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7726                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7727                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7728                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7729                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7730                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7731                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7732                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7733                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7734                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_rodc));
7736                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7737                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7738                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7739                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7740                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7741         }
7742         if (ndr_flags & NDR_BUFFERS) {
7743                 if (r->netbios_name) {
7744                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7745                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7746                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7747                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7748                 }
7749                 if (r->dns_name) {
7750                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7751                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7752                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7753                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7754                 }
7755                 if (r->site_name) {
7756                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7757                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7758                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7759                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7760                 }
7761                 if (r->site_dn) {
7762                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7763                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7764                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7765                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7766                 }
7767                 if (r->computer_dn) {
7768                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7769                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7770                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7771                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7772                 }
7773                 if (r->server_dn) {
7774                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7775                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7776                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7777                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7778                 }
7779                 if (r->ntds_dn) {
7780                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7781                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7782                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7783                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7784                 }
7785         }
7786         return NDR_ERR_SUCCESS;
7787 }
7788
7789 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo3 *r)
7790 {
7791         uint32_t _ptr_netbios_name;
7792         TALLOC_CTX *_mem_save_netbios_name_0;
7793         uint32_t _ptr_dns_name;
7794         TALLOC_CTX *_mem_save_dns_name_0;
7795         uint32_t _ptr_site_name;
7796         TALLOC_CTX *_mem_save_site_name_0;
7797         uint32_t _ptr_site_dn;
7798         TALLOC_CTX *_mem_save_site_dn_0;
7799         uint32_t _ptr_computer_dn;
7800         TALLOC_CTX *_mem_save_computer_dn_0;
7801         uint32_t _ptr_server_dn;
7802         TALLOC_CTX *_mem_save_server_dn_0;
7803         uint32_t _ptr_ntds_dn;
7804         TALLOC_CTX *_mem_save_ntds_dn_0;
7805         if (ndr_flags & NDR_SCALARS) {
7806                 NDR_CHECK(ndr_pull_align(ndr, 5));
7807                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7808                 if (_ptr_netbios_name) {
7809                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7810                 } else {
7811                         r->netbios_name = NULL;
7812                 }
7813                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7814                 if (_ptr_dns_name) {
7815                         NDR_PULL_ALLOC(ndr, r->dns_name);
7816                 } else {
7817                         r->dns_name = NULL;
7818                 }
7819                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7820                 if (_ptr_site_name) {
7821                         NDR_PULL_ALLOC(ndr, r->site_name);
7822                 } else {
7823                         r->site_name = NULL;
7824                 }
7825                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7826                 if (_ptr_site_dn) {
7827                         NDR_PULL_ALLOC(ndr, r->site_dn);
7828                 } else {
7829                         r->site_dn = NULL;
7830                 }
7831                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7832                 if (_ptr_computer_dn) {
7833                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7834                 } else {
7835                         r->computer_dn = NULL;
7836                 }
7837                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7838                 if (_ptr_server_dn) {
7839                         NDR_PULL_ALLOC(ndr, r->server_dn);
7840                 } else {
7841                         r->server_dn = NULL;
7842                 }
7843                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7844                 if (_ptr_ntds_dn) {
7845                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7846                 } else {
7847                         r->ntds_dn = NULL;
7848                 }
7849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7850                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7852                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_rodc));
7853                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7854                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7855                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7856                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7857                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7858         }
7859         if (ndr_flags & NDR_BUFFERS) {
7860                 if (r->netbios_name) {
7861                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7862                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7863                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7864                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7865                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7866                                 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));
7867                         }
7868                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7869                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7870                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7871                 }
7872                 if (r->dns_name) {
7873                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7874                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7875                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7876                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7877                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7878                                 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));
7879                         }
7880                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7881                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7882                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7883                 }
7884                 if (r->site_name) {
7885                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7886                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7887                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7888                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7889                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7890                                 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));
7891                         }
7892                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7893                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7894                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7895                 }
7896                 if (r->site_dn) {
7897                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7898                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7899                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7900                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7901                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7902                                 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));
7903                         }
7904                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7905                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7906                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7907                 }
7908                 if (r->computer_dn) {
7909                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7910                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7911                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7912                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7913                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7914                                 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));
7915                         }
7916                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7917                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7919                 }
7920                 if (r->server_dn) {
7921                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7922                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7923                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7924                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7925                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7926                                 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));
7927                         }
7928                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7929                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7930                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7931                 }
7932                 if (r->ntds_dn) {
7933                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7934                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7935                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7936                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7937                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7938                                 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));
7939                         }
7940                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7941                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7942                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7943                 }
7944         }
7945         return NDR_ERR_SUCCESS;
7946 }
7947
7948 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo3 *r)
7949 {
7950         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo3");
7951         ndr->depth++;
7952         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7953         ndr->depth++;
7954         if (r->netbios_name) {
7955                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7956         }
7957         ndr->depth--;
7958         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7959         ndr->depth++;
7960         if (r->dns_name) {
7961                 ndr_print_string(ndr, "dns_name", r->dns_name);
7962         }
7963         ndr->depth--;
7964         ndr_print_ptr(ndr, "site_name", r->site_name);
7965         ndr->depth++;
7966         if (r->site_name) {
7967                 ndr_print_string(ndr, "site_name", r->site_name);
7968         }
7969         ndr->depth--;
7970         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7971         ndr->depth++;
7972         if (r->site_dn) {
7973                 ndr_print_string(ndr, "site_dn", r->site_dn);
7974         }
7975         ndr->depth--;
7976         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7977         ndr->depth++;
7978         if (r->computer_dn) {
7979                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7980         }
7981         ndr->depth--;
7982         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7983         ndr->depth++;
7984         if (r->server_dn) {
7985                 ndr_print_string(ndr, "server_dn", r->server_dn);
7986         }
7987         ndr->depth--;
7988         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7989         ndr->depth++;
7990         if (r->ntds_dn) {
7991                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7992         }
7993         ndr->depth--;
7994         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7995         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7996         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7997         ndr_print_uint32(ndr, "is_rodc", r->is_rodc);
7998         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7999         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
8000         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
8001         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
8002         ndr->depth--;
8003 }
8004
8005 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr3 *r)
8006 {
8007         uint32_t cntr_array_1;
8008         if (ndr_flags & NDR_SCALARS) {
8009                 NDR_CHECK(ndr_push_align(ndr, 5));
8010                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8011                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
8012                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8013         }
8014         if (ndr_flags & NDR_BUFFERS) {
8015                 if (r->array) {
8016                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
8017                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8018                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8019                         }
8020                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8021                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8022                         }
8023                 }
8024         }
8025         return NDR_ERR_SUCCESS;
8026 }
8027
8028 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr3 *r)
8029 {
8030         uint32_t _ptr_array;
8031         uint32_t cntr_array_1;
8032         TALLOC_CTX *_mem_save_array_0;
8033         TALLOC_CTX *_mem_save_array_1;
8034         if (ndr_flags & NDR_SCALARS) {
8035                 NDR_CHECK(ndr_pull_align(ndr, 5));
8036                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8037                 if (r->count > 10000) {
8038                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8039                 }
8040                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
8041                 if (_ptr_array) {
8042                         NDR_PULL_ALLOC(ndr, r->array);
8043                 } else {
8044                         r->array = NULL;
8045                 }
8046                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8047         }
8048         if (ndr_flags & NDR_BUFFERS) {
8049                 if (r->array) {
8050                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
8051                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8052                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
8053                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
8054                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
8055                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8056                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8057                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8058                         }
8059                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8060                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8061                         }
8062                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
8063                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
8064                 }
8065                 if (r->array) {
8066                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
8067                 }
8068         }
8069         return NDR_ERR_SUCCESS;
8070 }
8071
8072 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr3 *r)
8073 {
8074         uint32_t cntr_array_1;
8075         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr3");
8076         ndr->depth++;
8077         ndr_print_uint32(ndr, "count", r->count);
8078         ndr_print_ptr(ndr, "array", r->array);
8079         ndr->depth++;
8080         if (r->array) {
8081                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
8082                 ndr->depth++;
8083                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
8084                         char *idx_1=NULL;
8085                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8086                                 ndr_print_drsuapi_DsGetDCInfo3(ndr, "array", &r->array[cntr_array_1]);
8087                                 free(idx_1);
8088                         }
8089                 }
8090                 ndr->depth--;
8091         }
8092         ndr->depth--;
8093         ndr->depth--;
8094 }
8095
8096 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnection01 *r)
8097 {
8098         if (ndr_flags & NDR_SCALARS) {
8099                 NDR_CHECK(ndr_push_align(ndr, 5));
8100                 {
8101                         uint32_t _flags_save_ipv4address = ndr->flags;
8102                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
8103                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
8104                         ndr->flags = _flags_save_ipv4address;
8105                 }
8106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connection_time));
8108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
8109                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
8110                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
8111                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
8112                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8113         }
8114         if (ndr_flags & NDR_BUFFERS) {
8115                 if (r->client_account) {
8116                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
8117                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
8118                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
8119                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_account, ndr_charset_length(r->client_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8120                 }
8121         }
8122         return NDR_ERR_SUCCESS;
8123 }
8124
8125 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnection01 *r)
8126 {
8127         uint32_t _ptr_client_account;
8128         TALLOC_CTX *_mem_save_client_account_0;
8129         if (ndr_flags & NDR_SCALARS) {
8130                 NDR_CHECK(ndr_pull_align(ndr, 5));
8131                 {
8132                         uint32_t _flags_save_ipv4address = ndr->flags;
8133                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
8134                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
8135                         ndr->flags = _flags_save_ipv4address;
8136                 }
8137                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8138                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connection_time));
8139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
8140                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
8141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
8142                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_account));
8143                 if (_ptr_client_account) {
8144                         NDR_PULL_ALLOC(ndr, r->client_account);
8145                 } else {
8146                         r->client_account = NULL;
8147                 }
8148                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8149         }
8150         if (ndr_flags & NDR_BUFFERS) {
8151                 if (r->client_account) {
8152                         _mem_save_client_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8153                         NDR_PULL_SET_MEM_CTX(ndr, r->client_account, 0);
8154                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_account));
8155                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_account));
8156                         if (ndr_get_array_length(ndr, &r->client_account) > ndr_get_array_size(ndr, &r->client_account)) {
8157                                 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));
8158                         }
8159                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t)));
8160                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t), CH_UTF16));
8161                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_account_0, 0);
8162                 }
8163         }
8164         return NDR_ERR_SUCCESS;
8165 }
8166
8167 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnection01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnection01 *r)
8168 {
8169         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnection01");
8170         ndr->depth++;
8171         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
8172         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8173         ndr_print_uint32(ndr, "connection_time", r->connection_time);
8174         ndr_print_uint32(ndr, "unknown4", r->unknown4);
8175         ndr_print_uint32(ndr, "unknown5", r->unknown5);
8176         ndr_print_uint32(ndr, "unknown6", r->unknown6);
8177         ndr_print_ptr(ndr, "client_account", r->client_account);
8178         ndr->depth++;
8179         if (r->client_account) {
8180                 ndr_print_string(ndr, "client_account", r->client_account);
8181         }
8182         ndr->depth--;
8183         ndr->depth--;
8184 }
8185
8186 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8187 {
8188         uint32_t cntr_array_1;
8189         if (ndr_flags & NDR_SCALARS) {
8190                 NDR_CHECK(ndr_push_align(ndr, 5));
8191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8192                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
8193                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8194         }
8195         if (ndr_flags & NDR_BUFFERS) {
8196                 if (r->array) {
8197                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
8198                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8199                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8200                         }
8201                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8202                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8203                         }
8204                 }
8205         }
8206         return NDR_ERR_SUCCESS;
8207 }
8208
8209 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnectionCtr01 *r)
8210 {
8211         uint32_t _ptr_array;
8212         uint32_t cntr_array_1;
8213         TALLOC_CTX *_mem_save_array_0;
8214         TALLOC_CTX *_mem_save_array_1;
8215         if (ndr_flags & NDR_SCALARS) {
8216                 NDR_CHECK(ndr_pull_align(ndr, 5));
8217                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8218                 if (r->count > 10000) {
8219                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8220                 }
8221                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
8222                 if (_ptr_array) {
8223                         NDR_PULL_ALLOC(ndr, r->array);
8224                 } else {
8225                         r->array = NULL;
8226                 }
8227                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8228         }
8229         if (ndr_flags & NDR_BUFFERS) {
8230                 if (r->array) {
8231                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
8232                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8233                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
8234                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
8235                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
8236                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8237                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8238                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8239                         }
8240                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8241                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8242                         }
8243                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
8244                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
8245                 }
8246                 if (r->array) {
8247                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
8248                 }
8249         }
8250         return NDR_ERR_SUCCESS;
8251 }
8252
8253 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnectionCtr01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8254 {
8255         uint32_t cntr_array_1;
8256         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnectionCtr01");
8257         ndr->depth++;
8258         ndr_print_uint32(ndr, "count", r->count);
8259         ndr_print_ptr(ndr, "array", r->array);
8260         ndr->depth++;
8261         if (r->array) {
8262                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
8263                 ndr->depth++;
8264                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
8265                         char *idx_1=NULL;
8266                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8267                                 ndr_print_drsuapi_DsGetDCConnection01(ndr, "array", &r->array[cntr_array_1]);
8268                                 free(idx_1);
8269                         }
8270                 }
8271                 ndr->depth--;
8272         }
8273         ndr->depth--;
8274         ndr->depth--;
8275 }
8276
8277 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoCtr *r)
8278 {
8279         if (ndr_flags & NDR_SCALARS) {
8280                 int level = ndr_push_get_switch_value(ndr, r);
8281                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8282                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8283                 switch (level) {
8284                         case DRSUAPI_DC_INFO_CTR_1: {
8285                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8286                         break; }
8287
8288                         case DRSUAPI_DC_INFO_CTR_2: {
8289                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8290                         break; }
8291
8292                         case DRSUAPI_DC_INFO_CTR_3: {
8293                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8294                         break; }
8295
8296                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8297                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8298                         break; }
8299
8300                         default:
8301                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8302                 }
8303         }
8304         if (ndr_flags & NDR_BUFFERS) {
8305                 int level = ndr_push_get_switch_value(ndr, r);
8306                 switch (level) {
8307                         case DRSUAPI_DC_INFO_CTR_1:
8308                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8309                         break;
8310
8311                         case DRSUAPI_DC_INFO_CTR_2:
8312                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8313                         break;
8314
8315                         case DRSUAPI_DC_INFO_CTR_3:
8316                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8317                         break;
8318
8319                         case DRSUAPI_DC_CONNECTION_CTR_01:
8320                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8321                         break;
8322
8323                         default:
8324                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8325                 }
8326         }
8327         return NDR_ERR_SUCCESS;
8328 }
8329
8330 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoCtr *r)
8331 {
8332         int level;
8333         int32_t _level;
8334         level = ndr_pull_get_switch_value(ndr, r);
8335         if (ndr_flags & NDR_SCALARS) {
8336                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8337                 if (_level != level) {
8338                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8339                 }
8340                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8341                 switch (level) {
8342                         case DRSUAPI_DC_INFO_CTR_1: {
8343                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8344                         break; }
8345
8346                         case DRSUAPI_DC_INFO_CTR_2: {
8347                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8348                         break; }
8349
8350                         case DRSUAPI_DC_INFO_CTR_3: {
8351                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8352                         break; }
8353
8354                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8355                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8356                         break; }
8357
8358                         default:
8359                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8360                 }
8361         }
8362         if (ndr_flags & NDR_BUFFERS) {
8363                 switch (level) {
8364                         case DRSUAPI_DC_INFO_CTR_1:
8365                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8366                         break;
8367
8368                         case DRSUAPI_DC_INFO_CTR_2:
8369                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8370                         break;
8371
8372                         case DRSUAPI_DC_INFO_CTR_3:
8373                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8374                         break;
8375
8376                         case DRSUAPI_DC_CONNECTION_CTR_01:
8377                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8378                         break;
8379
8380                         default:
8381                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8382                 }
8383         }
8384         return NDR_ERR_SUCCESS;
8385 }
8386
8387 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoCtr *r)
8388 {
8389         int level;
8390         level = ndr_print_get_switch_value(ndr, r);
8391         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoCtr");
8392         switch (level) {
8393                 case DRSUAPI_DC_INFO_CTR_1:
8394                         ndr_print_drsuapi_DsGetDCInfoCtr1(ndr, "ctr1", &r->ctr1);
8395                 break;
8396
8397                 case DRSUAPI_DC_INFO_CTR_2:
8398                         ndr_print_drsuapi_DsGetDCInfoCtr2(ndr, "ctr2", &r->ctr2);
8399                 break;
8400
8401                 case DRSUAPI_DC_INFO_CTR_3:
8402                         ndr_print_drsuapi_DsGetDCInfoCtr3(ndr, "ctr3", &r->ctr3);
8403                 break;
8404
8405                 case DRSUAPI_DC_CONNECTION_CTR_01:
8406                         ndr_print_drsuapi_DsGetDCConnectionCtr01(ndr, "ctr01", &r->ctr01);
8407                 break;
8408
8409                 default:
8410                         ndr_print_bad_level(ndr, name, level);
8411         }
8412 }
8413
8414 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItem *r)
8415 {
8416         if (ndr_flags & NDR_SCALARS) {
8417                 NDR_CHECK(ndr_push_align(ndr, 5));
8418                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
8419                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8420                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8421         }
8422         if (ndr_flags & NDR_BUFFERS) {
8423                 if (r->next_object) {
8424                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8425                 }
8426                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8427         }
8428         return NDR_ERR_SUCCESS;
8429 }
8430
8431 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItem *r)
8432 {
8433         uint32_t _ptr_next_object;
8434         TALLOC_CTX *_mem_save_next_object_0;
8435         if (ndr_flags & NDR_SCALARS) {
8436                 NDR_CHECK(ndr_pull_align(ndr, 5));
8437                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
8438                 if (_ptr_next_object) {
8439                         NDR_PULL_ALLOC(ndr, r->next_object);
8440                 } else {
8441                         r->next_object = NULL;
8442                 }
8443                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8444                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8445         }
8446         if (ndr_flags & NDR_BUFFERS) {
8447                 if (r->next_object) {
8448                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
8449                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
8450                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8451                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
8452                 }
8453                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8454         }
8455         return NDR_ERR_SUCCESS;
8456 }
8457
8458 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryRequest2 *r)
8459 {
8460         if (ndr_flags & NDR_SCALARS) {
8461                 NDR_CHECK(ndr_push_align(ndr, 5));
8462                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8463                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8464         }
8465         if (ndr_flags & NDR_BUFFERS) {
8466                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8467         }
8468         return NDR_ERR_SUCCESS;
8469 }
8470
8471 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryRequest2 *r)
8472 {
8473         if (ndr_flags & NDR_SCALARS) {
8474                 NDR_CHECK(ndr_pull_align(ndr, 5));
8475                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8476                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8477         }
8478         if (ndr_flags & NDR_BUFFERS) {
8479                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8480         }
8481         return NDR_ERR_SUCCESS;
8482 }
8483
8484 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryRequest2 *r)
8485 {
8486         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryRequest2");
8487         ndr->depth++;
8488         ndr_print_drsuapi_DsReplicaObjectListItem(ndr, "first_object", &r->first_object);
8489         ndr->depth--;
8490 }
8491
8492 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryRequest *r)
8493 {
8494         if (ndr_flags & NDR_SCALARS) {
8495                 int level = ndr_push_get_switch_value(ndr, r);
8496                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8497                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8498                 switch (level) {
8499                         case 2: {
8500                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8501                         break; }
8502
8503                         default:
8504                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8505                 }
8506         }
8507         if (ndr_flags & NDR_BUFFERS) {
8508                 int level = ndr_push_get_switch_value(ndr, r);
8509                 switch (level) {
8510                         case 2:
8511                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8512                         break;
8513
8514                         default:
8515                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8516                 }
8517         }
8518         return NDR_ERR_SUCCESS;
8519 }
8520
8521 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryRequest *r)
8522 {
8523         int level;
8524         int32_t _level;
8525         level = ndr_pull_get_switch_value(ndr, r);
8526         if (ndr_flags & NDR_SCALARS) {
8527                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8528                 if (_level != level) {
8529                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8530                 }
8531                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8532                 switch (level) {
8533                         case 2: {
8534                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8535                         break; }
8536
8537                         default:
8538                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8539                 }
8540         }
8541         if (ndr_flags & NDR_BUFFERS) {
8542                 switch (level) {
8543                         case 2:
8544                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8545                         break;
8546
8547                         default:
8548                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8549                 }
8550         }
8551         return NDR_ERR_SUCCESS;
8552 }
8553
8554 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryRequest *r)
8555 {
8556         int level;
8557         level = ndr_print_get_switch_value(ndr, r);
8558         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryRequest");
8559         switch (level) {
8560                 case 2:
8561                         ndr_print_drsuapi_DsAddEntryRequest2(ndr, "req2", &r->req2);
8562                 break;
8563
8564                 default:
8565                         ndr_print_bad_level(ndr, name, level);
8566         }
8567 }
8568
8569 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfoX *r)
8570 {
8571         if (ndr_flags & NDR_SCALARS) {
8572                 NDR_CHECK(ndr_push_align(ndr, 4));
8573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8574                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8576                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
8577                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8578         }
8579         if (ndr_flags & NDR_BUFFERS) {
8580         }
8581         return NDR_ERR_SUCCESS;
8582 }
8583
8584 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfoX *r)
8585 {
8586         if (ndr_flags & NDR_SCALARS) {
8587                 NDR_CHECK(ndr_pull_align(ndr, 4));
8588                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8589                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8591                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
8592                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8593         }
8594         if (ndr_flags & NDR_BUFFERS) {
8595         }
8596         return NDR_ERR_SUCCESS;
8597 }
8598
8599 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfoX(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfoX *r)
8600 {
8601         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfoX");
8602         ndr->depth++;
8603         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8604         ndr_print_WERROR(ndr, "status", r->status);
8605         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8606         ndr_print_uint16(ndr, "unknown3", r->unknown3);
8607         ndr->depth--;
8608 }
8609
8610 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8611 {
8612         if (ndr_flags & NDR_SCALARS) {
8613                 NDR_CHECK(ndr_push_align(ndr, 5));
8614                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8615                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
8616                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8617         }
8618         if (ndr_flags & NDR_BUFFERS) {
8619                 if (r->data) {
8620                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size));
8621                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
8622                 }
8623         }
8624         return NDR_ERR_SUCCESS;
8625 }
8626
8627 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8628 {
8629         uint32_t _ptr_data;
8630         TALLOC_CTX *_mem_save_data_0;
8631         if (ndr_flags & NDR_SCALARS) {
8632                 NDR_CHECK(ndr_pull_align(ndr, 5));
8633                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8634                 if (r->size > 10485760) {
8635                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8636                 }
8637                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
8638                 if (_ptr_data) {
8639                         NDR_PULL_ALLOC(ndr, r->data);
8640                 } else {
8641                         r->data = NULL;
8642                 }
8643                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8644         }
8645         if (ndr_flags & NDR_BUFFERS) {
8646                 if (r->data) {
8647                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
8648                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
8649                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
8650                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
8651                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
8652                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
8653                 }
8654                 if (r->data) {
8655                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
8656                 }
8657         }
8658         return NDR_ERR_SUCCESS;
8659 }
8660
8661 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8662 {
8663         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraErrorBuffer");
8664         ndr->depth++;
8665         ndr_print_uint32(ndr, "size", r->size);
8666         ndr_print_ptr(ndr, "data", r->data);
8667         ndr->depth++;
8668         if (r->data) {
8669                 ndr_print_array_uint8(ndr, "data", r->data, r->size);
8670         }
8671         ndr->depth--;
8672         ndr->depth--;
8673 }
8674
8675 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraError1 *r)
8676 {
8677         if (ndr_flags & NDR_SCALARS) {
8678                 NDR_CHECK(ndr_push_align(ndr, 5));
8679                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8680                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
8681                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8682                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8683                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8684         }
8685         if (ndr_flags & NDR_BUFFERS) {
8686                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8687         }
8688         return NDR_ERR_SUCCESS;
8689 }
8690
8691 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraError1 *r)
8692 {
8693         if (ndr_flags & NDR_SCALARS) {
8694                 NDR_CHECK(ndr_pull_align(ndr, 5));
8695                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8696                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
8697                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8698                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8699                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8700         }
8701         if (ndr_flags & NDR_BUFFERS) {
8702                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8703         }
8704         return NDR_ERR_SUCCESS;
8705 }
8706
8707 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraError1 *r)
8708 {
8709         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraError1");
8710         ndr->depth++;
8711         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8712         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
8713         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8714         ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(ndr, "buffer", &r->buffer);
8715         ndr->depth--;
8716 }
8717
8718 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8719 {
8720         if (ndr_flags & NDR_SCALARS) {
8721                 NDR_CHECK(ndr_push_align(ndr, 5));
8722                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
8723                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8724                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8725         }
8726         if (ndr_flags & NDR_BUFFERS) {
8727                 if (r->next) {
8728                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8729                 }
8730                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8731         }
8732         return NDR_ERR_SUCCESS;
8733 }
8734
8735 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorListItem1 *r)
8736 {
8737         uint32_t _ptr_next;
8738         TALLOC_CTX *_mem_save_next_0;
8739         if (ndr_flags & NDR_SCALARS) {
8740                 NDR_CHECK(ndr_pull_align(ndr, 5));
8741                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
8742                 if (_ptr_next) {
8743                         NDR_PULL_ALLOC(ndr, r->next);
8744                 } else {
8745                         r->next = NULL;
8746                 }
8747                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8748                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8749         }
8750         if (ndr_flags & NDR_BUFFERS) {
8751                 if (r->next) {
8752                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
8753                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
8754                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8755                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
8756                 }
8757                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8758         }
8759         return NDR_ERR_SUCCESS;
8760 }
8761
8762 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorListItem1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8763 {
8764         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorListItem1");
8765         ndr->depth++;
8766         ndr_print_ptr(ndr, "next", r->next);
8767         ndr->depth++;
8768         if (r->next) {
8769                 ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "next", r->next);
8770         }
8771         ndr->depth--;
8772         ndr_print_drsuapi_DsAddEntryExtraError1(ndr, "error", &r->error);
8773         ndr->depth--;
8774 }
8775
8776 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8777 {
8778         if (ndr_flags & NDR_SCALARS) {
8779                 NDR_CHECK(ndr_push_align(ndr, 5));
8780                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8781                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8782                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8783                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8784         }
8785         if (ndr_flags & NDR_BUFFERS) {
8786                 if (r->id) {
8787                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8788                 }
8789                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8790         }
8791         return NDR_ERR_SUCCESS;
8792 }
8793
8794 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfo1 *r)
8795 {
8796         uint32_t _ptr_id;
8797         TALLOC_CTX *_mem_save_id_0;
8798         if (ndr_flags & NDR_SCALARS) {
8799                 NDR_CHECK(ndr_pull_align(ndr, 5));
8800                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8801                 if (_ptr_id) {
8802                         NDR_PULL_ALLOC(ndr, r->id);
8803                 } else {
8804                         r->id = NULL;
8805                 }
8806                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8807                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8808                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8809         }
8810         if (ndr_flags & NDR_BUFFERS) {
8811                 if (r->id) {
8812                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8813                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8814                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8815                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8816                 }
8817                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8818         }
8819         return NDR_ERR_SUCCESS;
8820 }
8821
8822 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8823 {
8824         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfo1");
8825         ndr->depth++;
8826         ndr_print_ptr(ndr, "id", r->id);
8827         ndr->depth++;
8828         if (r->id) {
8829                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8830         }
8831         ndr->depth--;
8832         ndr_print_WERROR(ndr, "status", r->status);
8833         ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "first", &r->first);
8834         ndr->depth--;
8835 }
8836
8837 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryErrorInfo *r)
8838 {
8839         if (ndr_flags & NDR_SCALARS) {
8840                 int level = ndr_push_get_switch_value(ndr, r);
8841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8842                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8843                 switch (level) {
8844                         case 1: {
8845                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8846                         break; }
8847
8848                         case 4: {
8849                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8850                         break; }
8851
8852                         case 5: {
8853                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8854                         break; }
8855
8856                         case 6: {
8857                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8858                         break; }
8859
8860                         case 7: {
8861                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8862                         break; }
8863
8864                         default:
8865                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8866                 }
8867         }
8868         if (ndr_flags & NDR_BUFFERS) {
8869                 int level = ndr_push_get_switch_value(ndr, r);
8870                 switch (level) {
8871                         case 1:
8872                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8873                         break;
8874
8875                         case 4:
8876                         break;
8877
8878                         case 5:
8879                         break;
8880
8881                         case 6:
8882                         break;
8883
8884                         case 7:
8885                         break;
8886
8887                         default:
8888                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8889                 }
8890         }
8891         return NDR_ERR_SUCCESS;
8892 }
8893
8894 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryErrorInfo *r)
8895 {
8896         int level;
8897         uint32_t _level;
8898         level = ndr_pull_get_switch_value(ndr, r);
8899         if (ndr_flags & NDR_SCALARS) {
8900                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8901                 if (_level != level) {
8902                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8903                 }
8904                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8905                 switch (level) {
8906                         case 1: {
8907                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8908                         break; }
8909
8910                         case 4: {
8911                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8912                         break; }
8913
8914                         case 5: {
8915                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8916                         break; }
8917
8918                         case 6: {
8919                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8920                         break; }
8921
8922                         case 7: {
8923                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8924                         break; }
8925
8926                         default:
8927                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8928                 }
8929         }
8930         if (ndr_flags & NDR_BUFFERS) {
8931                 switch (level) {
8932                         case 1:
8933                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8934                         break;
8935
8936                         case 4:
8937                         break;
8938
8939                         case 5:
8940                         break;
8941
8942                         case 6:
8943                         break;
8944
8945                         case 7:
8946                         break;
8947
8948                         default:
8949                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8950                 }
8951         }
8952         return NDR_ERR_SUCCESS;
8953 }
8954
8955 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryErrorInfo *r)
8956 {
8957         int level;
8958         level = ndr_print_get_switch_value(ndr, r);
8959         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryErrorInfo");
8960         switch (level) {
8961                 case 1:
8962                         ndr_print_drsuapi_DsAddEntryErrorInfo1(ndr, "error1", &r->error1);
8963                 break;
8964
8965                 case 4:
8966                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8967                 break;
8968
8969                 case 5:
8970                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8971                 break;
8972
8973                 case 6:
8974                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8975                 break;
8976
8977                 case 7:
8978                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8979                 break;
8980
8981                 default:
8982                         ndr_print_bad_level(ndr, name, level);
8983         }
8984 }
8985
8986 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryError1 *r)
8987 {
8988         if (ndr_flags & NDR_SCALARS) {
8989                 NDR_CHECK(ndr_push_align(ndr, 5));
8990                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8991                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8992                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
8993                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8994         }
8995         if (ndr_flags & NDR_BUFFERS) {
8996                 if (r->info) {
8997                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->info, r->level));
8998                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8999                 }
9000         }
9001         return NDR_ERR_SUCCESS;
9002 }
9003
9004 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryError1 *r)
9005 {
9006         uint32_t _ptr_info;
9007         TALLOC_CTX *_mem_save_info_0;
9008         if (ndr_flags & NDR_SCALARS) {
9009                 NDR_CHECK(ndr_pull_align(ndr, 5));
9010                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
9011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9012                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9013                 if (_ptr_info) {
9014                         NDR_PULL_ALLOC(ndr, r->info);
9015                 } else {
9016                         r->info = NULL;
9017                 }
9018                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9019         }
9020         if (ndr_flags & NDR_BUFFERS) {
9021                 if (r->info) {
9022                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9023                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
9024                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->info, r->level));
9025                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
9026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9027                 }
9028         }
9029         return NDR_ERR_SUCCESS;
9030 }
9031
9032 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryError1 *r)
9033 {
9034         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryError1");
9035         ndr->depth++;
9036         ndr_print_WERROR(ndr, "status", r->status);
9037         ndr_print_uint32(ndr, "level", r->level);
9038         ndr_print_ptr(ndr, "info", r->info);
9039         ndr->depth++;
9040         if (r->info) {
9041                 ndr_print_set_switch_value(ndr, r->info, r->level);
9042                 ndr_print_drsuapi_DsAddEntryErrorInfo(ndr, "info", r->info);
9043         }
9044         ndr->depth--;
9045         ndr->depth--;
9046 }
9047
9048 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryError *r)
9049 {
9050         if (ndr_flags & NDR_SCALARS) {
9051                 int level = ndr_push_get_switch_value(ndr, r);
9052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9053                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9054                 switch (level) {
9055                         case 1: {
9056                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
9057                         break; }
9058
9059                         default:
9060                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9061                 }
9062         }
9063         if (ndr_flags & NDR_BUFFERS) {
9064                 int level = ndr_push_get_switch_value(ndr, r);
9065                 switch (level) {
9066                         case 1:
9067                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
9068                         break;
9069
9070                         default:
9071                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9072                 }
9073         }
9074         return NDR_ERR_SUCCESS;
9075 }
9076
9077 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryError *r)
9078 {
9079         int level;
9080         uint32_t _level;
9081         level = ndr_pull_get_switch_value(ndr, r);
9082         if (ndr_flags & NDR_SCALARS) {
9083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9084                 if (_level != level) {
9085                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9086                 }
9087                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9088                 switch (level) {
9089                         case 1: {
9090                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
9091                         break; }
9092
9093                         default:
9094                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9095                 }
9096         }
9097         if (ndr_flags & NDR_BUFFERS) {
9098                 switch (level) {
9099                         case 1:
9100                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
9101                         break;
9102
9103                         default:
9104                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9105                 }
9106         }
9107         return NDR_ERR_SUCCESS;
9108 }
9109
9110 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryError *r)
9111 {
9112         int level;
9113         level = ndr_print_get_switch_value(ndr, r);
9114         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryError");
9115         switch (level) {
9116                 case 1:
9117                         ndr_print_drsuapi_DsAddEntryError1(ndr, "info1", &r->info1);
9118                 break;
9119
9120                 default:
9121                         ndr_print_bad_level(ndr, name, level);
9122         }
9123 }
9124
9125 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9126 {
9127         if (ndr_flags & NDR_SCALARS) {
9128                 NDR_CHECK(ndr_push_align(ndr, 4));
9129                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
9130                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9131                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9132         }
9133         if (ndr_flags & NDR_BUFFERS) {
9134                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9135         }
9136         return NDR_ERR_SUCCESS;
9137 }
9138
9139 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier2 *r)
9140 {
9141         if (ndr_flags & NDR_SCALARS) {
9142                 NDR_CHECK(ndr_pull_align(ndr, 4));
9143                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
9144                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9145                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9146         }
9147         if (ndr_flags & NDR_BUFFERS) {
9148                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9149         }
9150         return NDR_ERR_SUCCESS;
9151 }
9152
9153 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9154 {
9155         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier2");
9156         ndr->depth++;
9157         ndr_print_GUID(ndr, "guid", &r->guid);
9158         ndr_print_dom_sid28(ndr, "sid", &r->sid);
9159         ndr->depth--;
9160 }
9161
9162 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr2 *r)
9163 {
9164         uint32_t cntr_objects_1;
9165         if (ndr_flags & NDR_SCALARS) {
9166                 NDR_CHECK(ndr_push_align(ndr, 5));
9167                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9169                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9171                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9172                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9173         }
9174         if (ndr_flags & NDR_BUFFERS) {
9175                 if (r->id) {
9176                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9177                 }
9178                 if (r->objects) {
9179                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9180                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9181                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9182                         }
9183                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9184                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9185                         }
9186                 }
9187         }
9188         return NDR_ERR_SUCCESS;
9189 }
9190
9191 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr2 *r)
9192 {
9193         uint32_t _ptr_id;
9194         TALLOC_CTX *_mem_save_id_0;
9195         uint32_t _ptr_objects;
9196         uint32_t cntr_objects_1;
9197         TALLOC_CTX *_mem_save_objects_0;
9198         TALLOC_CTX *_mem_save_objects_1;
9199         if (ndr_flags & NDR_SCALARS) {
9200                 NDR_CHECK(ndr_pull_align(ndr, 5));
9201                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9202                 if (_ptr_id) {
9203                         NDR_PULL_ALLOC(ndr, r->id);
9204                 } else {
9205                         r->id = NULL;
9206                 }
9207                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9208                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9209                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9210                 if (r->count > 10000) {
9211                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9212                 }
9213                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9214                 if (_ptr_objects) {
9215                         NDR_PULL_ALLOC(ndr, r->objects);
9216                 } else {
9217                         r->objects = NULL;
9218                 }
9219                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9220         }
9221         if (ndr_flags & NDR_BUFFERS) {
9222                 if (r->id) {
9223                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9224                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9225                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9226                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9227                 }
9228                 if (r->objects) {
9229                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9230                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9231                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9232                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9233                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9234                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9235                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9236                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9237                         }
9238                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9239                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9240                         }
9241                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9242                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9243                 }
9244                 if (r->objects) {
9245                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9246                 }
9247         }
9248         return NDR_ERR_SUCCESS;
9249 }
9250
9251 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr2 *r)
9252 {
9253         uint32_t cntr_objects_1;
9254         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr2");
9255         ndr->depth++;
9256         ndr_print_ptr(ndr, "id", r->id);
9257         ndr->depth++;
9258         if (r->id) {
9259                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9260         }
9261         ndr->depth--;
9262         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9263         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
9264         ndr_print_uint32(ndr, "count", r->count);
9265         ndr_print_ptr(ndr, "objects", r->objects);
9266         ndr->depth++;
9267         if (r->objects) {
9268                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9269                 ndr->depth++;
9270                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9271                         char *idx_1=NULL;
9272                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9273                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9274                                 free(idx_1);
9275                         }
9276                 }
9277                 ndr->depth--;
9278         }
9279         ndr->depth--;
9280         ndr->depth--;
9281 }
9282
9283 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr3 *r)
9284 {
9285         uint32_t cntr_objects_1;
9286         if (ndr_flags & NDR_SCALARS) {
9287                 NDR_CHECK(ndr_push_align(ndr, 5));
9288                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9290                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
9291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9292                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9293                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9294         }
9295         if (ndr_flags & NDR_BUFFERS) {
9296                 if (r->id) {
9297                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9298                 }
9299                 if (r->error) {
9300                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->error, r->level));
9301                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9302                 }
9303                 if (r->objects) {
9304                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9305                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9306                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9307                         }
9308                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9309                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9310                         }
9311                 }
9312         }
9313         return NDR_ERR_SUCCESS;
9314 }
9315
9316 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr3 *r)
9317 {
9318         uint32_t _ptr_id;
9319         TALLOC_CTX *_mem_save_id_0;
9320         uint32_t _ptr_error;
9321         TALLOC_CTX *_mem_save_error_0;
9322         uint32_t _ptr_objects;
9323         uint32_t cntr_objects_1;
9324         TALLOC_CTX *_mem_save_objects_0;
9325         TALLOC_CTX *_mem_save_objects_1;
9326         if (ndr_flags & NDR_SCALARS) {
9327                 NDR_CHECK(ndr_pull_align(ndr, 5));
9328                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9329                 if (_ptr_id) {
9330                         NDR_PULL_ALLOC(ndr, r->id);
9331                 } else {
9332                         r->id = NULL;
9333                 }
9334                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9335                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_error));
9336                 if (_ptr_error) {
9337                         NDR_PULL_ALLOC(ndr, r->error);
9338                 } else {
9339                         r->error = NULL;
9340                 }
9341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9342                 if (r->count > 10000) {
9343                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9344                 }
9345                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9346                 if (_ptr_objects) {
9347                         NDR_PULL_ALLOC(ndr, r->objects);
9348                 } else {
9349                         r->objects = NULL;
9350                 }
9351                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9352         }
9353         if (ndr_flags & NDR_BUFFERS) {
9354                 if (r->id) {
9355                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9356                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9357                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9358                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9359                 }
9360                 if (r->error) {
9361                         _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
9362                         NDR_PULL_SET_MEM_CTX(ndr, r->error, 0);
9363                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->error, r->level));
9364                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9365                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, 0);
9366                 }
9367                 if (r->objects) {
9368                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9369                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9370                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9371                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9372                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9373                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9374                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9375                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9376                         }
9377                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9378                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9379                         }
9380                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9381                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9382                 }
9383                 if (r->objects) {
9384                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9385                 }
9386         }
9387         return NDR_ERR_SUCCESS;
9388 }
9389
9390 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr3 *r)
9391 {
9392         uint32_t cntr_objects_1;
9393         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr3");
9394         ndr->depth++;
9395         ndr_print_ptr(ndr, "id", r->id);
9396         ndr->depth++;
9397         if (r->id) {
9398                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9399         }
9400         ndr->depth--;
9401         ndr_print_uint32(ndr, "level", r->level);
9402         ndr_print_ptr(ndr, "error", r->error);
9403         ndr->depth++;
9404         if (r->error) {
9405                 ndr_print_set_switch_value(ndr, r->error, r->level);
9406                 ndr_print_drsuapi_DsAddEntryError(ndr, "error", r->error);
9407         }
9408         ndr->depth--;
9409         ndr_print_uint32(ndr, "count", r->count);
9410         ndr_print_ptr(ndr, "objects", r->objects);
9411         ndr->depth++;
9412         if (r->objects) {
9413                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9414                 ndr->depth++;
9415                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9416                         char *idx_1=NULL;
9417                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9418                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9419                                 free(idx_1);
9420                         }
9421                 }
9422                 ndr->depth--;
9423         }
9424         ndr->depth--;
9425         ndr->depth--;
9426 }
9427
9428 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryCtr *r)
9429 {
9430         if (ndr_flags & NDR_SCALARS) {
9431                 int level = ndr_push_get_switch_value(ndr, r);
9432                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
9433                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9434                 switch (level) {
9435                         case 2: {
9436                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9437                         break; }
9438
9439                         case 3: {
9440                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9441                         break; }
9442
9443                         default:
9444                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9445                 }
9446         }
9447         if (ndr_flags & NDR_BUFFERS) {
9448                 int level = ndr_push_get_switch_value(ndr, r);
9449                 switch (level) {
9450                         case 2:
9451                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9452                         break;
9453
9454                         case 3:
9455                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9456                         break;
9457
9458                         default:
9459                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9460                 }
9461         }
9462         return NDR_ERR_SUCCESS;
9463 }
9464
9465 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryCtr *r)
9466 {
9467         int level;
9468         int32_t _level;
9469         level = ndr_pull_get_switch_value(ndr, r);
9470         if (ndr_flags & NDR_SCALARS) {
9471                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
9472                 if (_level != level) {
9473                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9474                 }
9475                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9476                 switch (level) {
9477                         case 2: {
9478                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9479                         break; }
9480
9481                         case 3: {
9482                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9483                         break; }
9484
9485                         default:
9486                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9487                 }
9488         }
9489         if (ndr_flags & NDR_BUFFERS) {
9490                 switch (level) {
9491                         case 2:
9492                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9493                         break;
9494
9495                         case 3:
9496                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9497                         break;
9498
9499                         default:
9500                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9501                 }
9502         }
9503         return NDR_ERR_SUCCESS;
9504 }
9505
9506 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
9507 {
9508         int level;
9509         level = ndr_print_get_switch_value(ndr, r);
9510         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
9511         switch (level) {
9512                 case 2:
9513                         ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
9514                 break;
9515
9516                 case 3:
9517                         ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
9518                 break;
9519
9520                 default:
9521                         ndr_print_bad_level(ndr, name, level);
9522         }
9523 }
9524
9525 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9526 {
9527         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9528         return NDR_ERR_SUCCESS;
9529 }
9530
9531 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9532 {
9533         uint32_t v;
9534         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9535         *r = v;
9536         return NDR_ERR_SUCCESS;
9537 }
9538
9539 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCFlags(struct ndr_print *ndr, const char *name, uint32_t r)
9540 {
9541         ndr_print_uint32(ndr, name, r);
9542         ndr->depth++;
9543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION, r);
9544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_DAMPED", DRSUAPI_DS_EXECUTE_KCC_DAMPED, r);
9545         ndr->depth--;
9546 }
9547
9548 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsExecuteKCC1 *r)
9549 {
9550         if (ndr_flags & NDR_SCALARS) {
9551                 NDR_CHECK(ndr_push_align(ndr, 4));
9552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->taskID));
9553                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, r->flags));
9554                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9555         }
9556         if (ndr_flags & NDR_BUFFERS) {
9557         }
9558         return NDR_ERR_SUCCESS;
9559 }
9560
9561 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsExecuteKCC1 *r)
9562 {
9563         if (ndr_flags & NDR_SCALARS) {
9564                 NDR_CHECK(ndr_pull_align(ndr, 4));
9565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->taskID));
9566                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, &r->flags));
9567                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9568         }
9569         if (ndr_flags & NDR_BUFFERS) {
9570         }
9571         return NDR_ERR_SUCCESS;
9572 }
9573
9574 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsExecuteKCC1 *r)
9575 {
9576         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC1");
9577         ndr->depth++;
9578         ndr_print_uint32(ndr, "taskID", r->taskID);
9579         ndr_print_drsuapi_DsExecuteKCCFlags(ndr, "flags", r->flags);
9580         ndr->depth--;
9581 }
9582
9583 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsExecuteKCCRequest *r)
9584 {
9585         if (ndr_flags & NDR_SCALARS) {
9586                 int level = ndr_push_get_switch_value(ndr, r);
9587                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9588                 NDR_CHECK(ndr_push_union_align(ndr, 4));
9589                 switch (level) {
9590                         case 1: {
9591                                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9592                         break; }
9593
9594                         default:
9595                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9596                 }
9597         }
9598         if (ndr_flags & NDR_BUFFERS) {
9599                 int level = ndr_push_get_switch_value(ndr, r);
9600                 switch (level) {
9601                         case 1:
9602                         break;
9603
9604                         default:
9605                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9606                 }
9607         }
9608         return NDR_ERR_SUCCESS;
9609 }
9610
9611 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsExecuteKCCRequest *r)
9612 {
9613         int level;
9614         uint32_t _level;
9615         level = ndr_pull_get_switch_value(ndr, r);
9616         if (ndr_flags & NDR_SCALARS) {
9617                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9618                 if (_level != level) {
9619                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9620                 }
9621                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
9622                 switch (level) {
9623                         case 1: {
9624                                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9625                         break; }
9626
9627                         default:
9628                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9629                 }
9630         }
9631         if (ndr_flags & NDR_BUFFERS) {
9632                 switch (level) {
9633                         case 1:
9634                         break;
9635
9636                         default:
9637                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9638                 }
9639         }
9640         return NDR_ERR_SUCCESS;
9641 }
9642
9643 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsExecuteKCCRequest *r)
9644 {
9645         int level;
9646         level = ndr_print_get_switch_value(ndr, r);
9647         ndr_print_union(ndr, name, level, "drsuapi_DsExecuteKCCRequest");
9648         switch (level) {
9649                 case 1:
9650                         ndr_print_drsuapi_DsExecuteKCC1(ndr, "ctr1", &r->ctr1);
9651                 break;
9652
9653                 default:
9654                         ndr_print_bad_level(ndr, name, level);
9655         }
9656 }
9657
9658 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
9659 {
9660         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9661         return NDR_ERR_SUCCESS;
9662 }
9663
9664 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
9665 {
9666         uint32_t v;
9667         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9668         *r = v;
9669         return NDR_ERR_SUCCESS;
9670 }
9671
9672 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaGetInfoLevel r)
9673 {
9674         const char *val = NULL;
9675
9676         switch (r) {
9677                 case DRSUAPI_DS_REPLICA_GET_INFO: val = "DRSUAPI_DS_REPLICA_GET_INFO"; break;
9678                 case DRSUAPI_DS_REPLICA_GET_INFO2: val = "DRSUAPI_DS_REPLICA_GET_INFO2"; break;
9679         }
9680         ndr_print_enum(ndr, name, "ENUM", val, r);
9681 }
9682
9683 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
9684 {
9685         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9686         return NDR_ERR_SUCCESS;
9687 }
9688
9689 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
9690 {
9691         uint32_t v;
9692         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9693         *r = v;
9694         return NDR_ERR_SUCCESS;
9695 }
9696
9697 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaInfoType r)
9698 {
9699         const char *val = NULL;
9700
9701         switch (r) {
9702                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS"; break;
9703                 case DRSUAPI_DS_REPLICA_INFO_CURSORS: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS"; break;
9704                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA"; break;
9705                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES"; break;
9706                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES"; break;
9707                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: val = "DRSUAPI_DS_REPLICA_INFO_PENDING_OPS"; break;
9708                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA"; break;
9709                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS2"; break;
9710                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS3"; break;
9711                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2"; break;
9712                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2"; break;
9713                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02"; break;
9714                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: val = "DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04"; break;
9715                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS05"; break;
9716                 case DRSUAPI_DS_REPLICA_INFO_06: val = "DRSUAPI_DS_REPLICA_INFO_06"; break;
9717         }
9718         ndr_print_enum(ndr, name, "ENUM", val, r);
9719 }
9720
9721 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9722 {
9723         if (ndr_flags & NDR_SCALARS) {
9724                 NDR_CHECK(ndr_push_align(ndr, 5));
9725                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9726                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9727                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9728                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9729         }
9730         if (ndr_flags & NDR_BUFFERS) {
9731                 if (r->object_dn) {
9732                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9733                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9734                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9735                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9736                 }
9737         }
9738         return NDR_ERR_SUCCESS;
9739 }
9740
9741 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
9742 {
9743         uint32_t _ptr_object_dn;
9744         TALLOC_CTX *_mem_save_object_dn_0;
9745         if (ndr_flags & NDR_SCALARS) {
9746                 NDR_CHECK(ndr_pull_align(ndr, 5));
9747                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9748                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9749                 if (_ptr_object_dn) {
9750                         NDR_PULL_ALLOC(ndr, r->object_dn);
9751                 } else {
9752                         r->object_dn = NULL;
9753                 }
9754                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9755                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9756         }
9757         if (ndr_flags & NDR_BUFFERS) {
9758                 if (r->object_dn) {
9759                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9760                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9761                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9762                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9763                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9764                                 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));
9765                         }
9766                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9767                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9768                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9769                 }
9770         }
9771         return NDR_ERR_SUCCESS;
9772 }
9773
9774 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9775 {
9776         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest1");
9777         ndr->depth++;
9778         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9779         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9780         ndr->depth++;
9781         if (r->object_dn) {
9782                 ndr_print_string(ndr, "object_dn", r->object_dn);
9783         }
9784         ndr->depth--;
9785         ndr_print_GUID(ndr, "guid1", &r->guid1);
9786         ndr->depth--;
9787 }
9788
9789 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9790 {
9791         if (ndr_flags & NDR_SCALARS) {
9792                 NDR_CHECK(ndr_push_align(ndr, 5));
9793                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9794                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9795                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9797                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string1));
9798                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string2));
9799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
9800                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9801         }
9802         if (ndr_flags & NDR_BUFFERS) {
9803                 if (r->object_dn) {
9804                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9805                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9806                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9807                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9808                 }
9809                 if (r->string1) {
9810                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9811                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9812                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9813                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string1, ndr_charset_length(r->string1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9814                 }
9815                 if (r->string2) {
9816                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9817                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9818                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9819                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string2, ndr_charset_length(r->string2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9820                 }
9821         }
9822         return NDR_ERR_SUCCESS;
9823 }
9824
9825 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
9826 {
9827         uint32_t _ptr_object_dn;
9828         TALLOC_CTX *_mem_save_object_dn_0;
9829         uint32_t _ptr_string1;
9830         TALLOC_CTX *_mem_save_string1_0;
9831         uint32_t _ptr_string2;
9832         TALLOC_CTX *_mem_save_string2_0;
9833         if (ndr_flags & NDR_SCALARS) {
9834                 NDR_CHECK(ndr_pull_align(ndr, 5));
9835                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9836                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9837                 if (_ptr_object_dn) {
9838                         NDR_PULL_ALLOC(ndr, r->object_dn);
9839                 } else {
9840                         r->object_dn = NULL;
9841                 }
9842                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9844                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string1));
9845                 if (_ptr_string1) {
9846                         NDR_PULL_ALLOC(ndr, r->string1);
9847                 } else {
9848                         r->string1 = NULL;
9849                 }
9850                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string2));
9851                 if (_ptr_string2) {
9852                         NDR_PULL_ALLOC(ndr, r->string2);
9853                 } else {
9854                         r->string2 = NULL;
9855                 }
9856                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
9857                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9858         }
9859         if (ndr_flags & NDR_BUFFERS) {
9860                 if (r->object_dn) {
9861                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9862                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9863                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9864                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9865                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9866                                 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));
9867                         }
9868                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9869                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9870                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9871                 }
9872                 if (r->string1) {
9873                         _mem_save_string1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9874                         NDR_PULL_SET_MEM_CTX(ndr, r->string1, 0);
9875                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string1));
9876                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string1));
9877                         if (ndr_get_array_length(ndr, &r->string1) > ndr_get_array_size(ndr, &r->string1)) {
9878                                 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));
9879                         }
9880                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t)));
9881                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string1, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t), CH_UTF16));
9882                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string1_0, 0);
9883                 }
9884                 if (r->string2) {
9885                         _mem_save_string2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9886                         NDR_PULL_SET_MEM_CTX(ndr, r->string2, 0);
9887                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string2));
9888                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string2));
9889                         if (ndr_get_array_length(ndr, &r->string2) > ndr_get_array_size(ndr, &r->string2)) {
9890                                 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));
9891                         }
9892                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t)));
9893                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string2, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t), CH_UTF16));
9894                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string2_0, 0);
9895                 }
9896         }
9897         return NDR_ERR_SUCCESS;
9898 }
9899
9900 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9901 {
9902         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest2");
9903         ndr->depth++;
9904         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9905         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9906         ndr->depth++;
9907         if (r->object_dn) {
9908                 ndr_print_string(ndr, "object_dn", r->object_dn);
9909         }
9910         ndr->depth--;
9911         ndr_print_GUID(ndr, "guid1", &r->guid1);
9912         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9913         ndr_print_ptr(ndr, "string1", r->string1);
9914         ndr->depth++;
9915         if (r->string1) {
9916                 ndr_print_string(ndr, "string1", r->string1);
9917         }
9918         ndr->depth--;
9919         ndr_print_ptr(ndr, "string2", r->string2);
9920         ndr->depth++;
9921         if (r->string2) {
9922                 ndr_print_string(ndr, "string2", r->string2);
9923         }
9924         ndr->depth--;
9925         ndr_print_uint32(ndr, "unknown2", r->unknown2);
9926         ndr->depth--;
9927 }
9928
9929 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaGetInfoRequest *r)
9930 {
9931         if (ndr_flags & NDR_SCALARS) {
9932                 int level = ndr_push_get_switch_value(ndr, r);
9933                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
9934                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9935                 switch (level) {
9936                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9937                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9938                         break; }
9939
9940                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9941                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9942                         break; }
9943
9944                         default:
9945                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9946                 }
9947         }
9948         if (ndr_flags & NDR_BUFFERS) {
9949                 int level = ndr_push_get_switch_value(ndr, r);
9950                 switch (level) {
9951                         case DRSUAPI_DS_REPLICA_GET_INFO:
9952                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9953                         break;
9954
9955                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9956                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9957                         break;
9958
9959                         default:
9960                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9961                 }
9962         }
9963         return NDR_ERR_SUCCESS;
9964 }
9965
9966 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaGetInfoRequest *r)
9967 {
9968         int level;
9969         uint32_t _level;
9970         level = ndr_pull_get_switch_value(ndr, r);
9971         if (ndr_flags & NDR_SCALARS) {
9972                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9973                 if (_level != level) {
9974                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9975                 }
9976                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9977                 switch (level) {
9978                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9979                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9980                         break; }
9981
9982                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9983                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9984                         break; }
9985
9986                         default:
9987                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9988                 }
9989         }
9990         if (ndr_flags & NDR_BUFFERS) {
9991                 switch (level) {
9992                         case DRSUAPI_DS_REPLICA_GET_INFO:
9993                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9994                         break;
9995
9996                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9997                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9998                         break;
9999
10000                         default:
10001                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
10002                 }
10003         }
10004         return NDR_ERR_SUCCESS;
10005 }
10006
10007 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaGetInfoRequest *r)
10008 {
10009         int level;
10010         level = ndr_print_get_switch_value(ndr, r);
10011         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaGetInfoRequest");
10012         switch (level) {
10013                 case DRSUAPI_DS_REPLICA_GET_INFO:
10014                         ndr_print_drsuapi_DsReplicaGetInfoRequest1(ndr, "req1", &r->req1);
10015                 break;
10016
10017                 case DRSUAPI_DS_REPLICA_GET_INFO2:
10018                         ndr_print_drsuapi_DsReplicaGetInfoRequest2(ndr, "req2", &r->req2);
10019                 break;
10020
10021                 default:
10022                         ndr_print_bad_level(ndr, name, level);
10023         }
10024 }
10025
10026 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbour *r)
10027 {
10028         if (ndr_flags & NDR_SCALARS) {
10029                 NDR_CHECK(ndr_push_align(ndr, 8));
10030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context_dn));
10031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
10032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
10033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_obj_dn));
10034                 NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, r->replica_flags));
10035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10036                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
10037                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
10038                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
10039                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
10040                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
10041                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
10042                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_success));
10043                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
10044                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
10045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
10046                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10047         }
10048         if (ndr_flags & NDR_BUFFERS) {
10049                 if (r->naming_context_dn) {
10050                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
10051                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10052                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
10053                         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));
10054                 }
10055                 if (r->source_dsa_obj_dn) {
10056                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
10057                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10058                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
10059                         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));
10060                 }
10061                 if (r->source_dsa_address) {
10062                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
10063                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10064                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
10065                         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));
10066                 }
10067                 if (r->transport_obj_dn) {
10068                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
10069                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10070                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
10071                         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));
10072                 }
10073         }
10074         return NDR_ERR_SUCCESS;
10075 }
10076
10077 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
10078 {
10079         uint32_t _ptr_naming_context_dn;
10080         TALLOC_CTX *_mem_save_naming_context_dn_0;
10081         uint32_t _ptr_source_dsa_obj_dn;
10082         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
10083         uint32_t _ptr_source_dsa_address;
10084         TALLOC_CTX *_mem_save_source_dsa_address_0;
10085         uint32_t _ptr_transport_obj_dn;
10086         TALLOC_CTX *_mem_save_transport_obj_dn_0;
10087         if (ndr_flags & NDR_SCALARS) {
10088                 NDR_CHECK(ndr_pull_align(ndr, 8));
10089                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context_dn));
10090                 if (_ptr_naming_context_dn) {
10091                         NDR_PULL_ALLOC(ndr, r->naming_context_dn);
10092                 } else {
10093                         r->naming_context_dn = NULL;
10094                 }
10095                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
10096                 if (_ptr_source_dsa_obj_dn) {
10097                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
10098                 } else {
10099                         r->source_dsa_obj_dn = NULL;
10100                 }
10101                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
10102                 if (_ptr_source_dsa_address) {
10103                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
10104                 } else {
10105                         r->source_dsa_address = NULL;
10106                 }
10107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_obj_dn));
10108                 if (_ptr_transport_obj_dn) {
10109                         NDR_PULL_ALLOC(ndr, r->transport_obj_dn);
10110                 } else {
10111                         r->transport_obj_dn = NULL;
10112                 }
10113                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourFlags(ndr, NDR_SCALARS, &r->replica_flags));
10114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10115                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
10116                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
10117                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
10118                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
10119                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
10120                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
10121                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_success));
10122                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
10123                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
10124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
10125                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10126         }
10127         if (ndr_flags & NDR_BUFFERS) {
10128                 if (r->naming_context_dn) {
10129                         _mem_save_naming_context_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10130                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
10131                         NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
10132                         NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
10133                         if (ndr_get_array_length(ndr, &r->naming_context_dn) > ndr_get_array_size(ndr, &r->naming_context_dn)) {
10134                                 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));
10135                         }
10136                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t)));
10137                         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));
10138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
10139                 }
10140                 if (r->source_dsa_obj_dn) {
10141                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10142                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
10143                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
10144                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
10145                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
10146                                 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));
10147                         }
10148                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
10149                         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));
10150                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
10151                 }
10152                 if (r->source_dsa_address) {
10153                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10154                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
10155                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
10156                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
10157                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
10158                                 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));
10159                         }
10160                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
10161                         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));
10162                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
10163                 }
10164                 if (r->transport_obj_dn) {
10165                         _mem_save_transport_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10166                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
10167                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
10168                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
10169                         if (ndr_get_array_length(ndr, &r->transport_obj_dn) > ndr_get_array_size(ndr, &r->transport_obj_dn)) {
10170                                 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));
10171                         }
10172                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t)));
10173                         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));
10174                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
10175                 }
10176         }
10177         return NDR_ERR_SUCCESS;
10178 }
10179
10180 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbour(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbour *r)
10181 {
10182         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbour");
10183         ndr->depth++;
10184         ndr_print_ptr(ndr, "naming_context_dn", r->naming_context_dn);
10185         ndr->depth++;
10186         if (r->naming_context_dn) {
10187                 ndr_print_string(ndr, "naming_context_dn", r->naming_context_dn);
10188         }
10189         ndr->depth--;
10190         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10191         ndr->depth++;
10192         if (r->source_dsa_obj_dn) {
10193                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10194         }
10195         ndr->depth--;
10196         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
10197         ndr->depth++;
10198         if (r->source_dsa_address) {
10199                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
10200         }
10201         ndr->depth--;
10202         ndr_print_ptr(ndr, "transport_obj_dn", r->transport_obj_dn);
10203         ndr->depth++;
10204         if (r->transport_obj_dn) {
10205                 ndr_print_string(ndr, "transport_obj_dn", r->transport_obj_dn);
10206         }
10207         ndr->depth--;
10208         ndr_print_drsuapi_DsReplicaNeighbourFlags(ndr, "replica_flags", r->replica_flags);
10209         ndr_print_uint32(ndr, "reserved", r->reserved);
10210         ndr_print_GUID(ndr, "naming_context_obj_guid", &r->naming_context_obj_guid);
10211         ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
10212         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
10213         ndr_print_GUID(ndr, "transport_obj_guid", &r->transport_obj_guid);
10214         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
10215         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
10216         ndr_print_NTTIME(ndr, "last_success", r->last_success);
10217         ndr_print_NTTIME(ndr, "last_attempt", r->last_attempt);
10218         ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
10219         ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
10220         ndr->depth--;
10221 }
10222
10223 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbourCtr *r)
10224 {
10225         uint32_t cntr_array_0;
10226         if (ndr_flags & NDR_SCALARS) {
10227                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10228                 NDR_CHECK(ndr_push_align(ndr, 8));
10229                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10231                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10232                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10233                 }
10234                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10235         }
10236         if (ndr_flags & NDR_BUFFERS) {
10237                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10238                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10239                 }
10240         }
10241         return NDR_ERR_SUCCESS;
10242 }
10243
10244 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
10245 {
10246         uint32_t cntr_array_0;
10247         TALLOC_CTX *_mem_save_array_0;
10248         if (ndr_flags & NDR_SCALARS) {
10249                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10250                 NDR_CHECK(ndr_pull_align(ndr, 8));
10251                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10253                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10254                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10255                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10256                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10257                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10258                 }
10259                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10260                 if (r->array) {
10261                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10262                 }
10263                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10264         }
10265         if (ndr_flags & NDR_BUFFERS) {
10266                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10267                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10268                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10269                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10270                 }
10271                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10272         }
10273         return NDR_ERR_SUCCESS;
10274 }
10275
10276 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbourCtr *r)
10277 {
10278         uint32_t cntr_array_0;
10279         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbourCtr");
10280         ndr->depth++;
10281         ndr_print_uint32(ndr, "count", r->count);
10282         ndr_print_uint32(ndr, "reserved", r->reserved);
10283         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10284         ndr->depth++;
10285         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10286                 char *idx_0=NULL;
10287                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10288                         ndr_print_drsuapi_DsReplicaNeighbour(ndr, "array", &r->array[cntr_array_0]);
10289                         free(idx_0);
10290                 }
10291         }
10292         ndr->depth--;
10293         ndr->depth--;
10294 }
10295
10296 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtr *r)
10297 {
10298         uint32_t cntr_array_0;
10299         if (ndr_flags & NDR_SCALARS) {
10300                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10301                 NDR_CHECK(ndr_push_align(ndr, 8));
10302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10304                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10305                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10306                 }
10307                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10308         }
10309         if (ndr_flags & NDR_BUFFERS) {
10310         }
10311         return NDR_ERR_SUCCESS;
10312 }
10313
10314 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
10315 {
10316         uint32_t cntr_array_0;
10317         TALLOC_CTX *_mem_save_array_0;
10318         if (ndr_flags & NDR_SCALARS) {
10319                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10320                 NDR_CHECK(ndr_pull_align(ndr, 8));
10321                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10322                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10323                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10324                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10325                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10326                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10327                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10328                 }
10329                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10330                 if (r->array) {
10331                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10332                 }
10333                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10334         }
10335         if (ndr_flags & NDR_BUFFERS) {
10336         }
10337         return NDR_ERR_SUCCESS;
10338 }
10339
10340 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtr *r)
10341 {
10342         uint32_t cntr_array_0;
10343         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtr");
10344         ndr->depth++;
10345         ndr_print_uint32(ndr, "count", r->count);
10346         ndr_print_uint32(ndr, "reserved", r->reserved);
10347         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10348         ndr->depth++;
10349         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10350                 char *idx_0=NULL;
10351                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10352                         ndr_print_drsuapi_DsReplicaCursor(ndr, "array", &r->array[cntr_array_0]);
10353                         free(idx_0);
10354                 }
10355         }
10356         ndr->depth--;
10357         ndr->depth--;
10358 }
10359
10360 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData *r)
10361 {
10362         if (ndr_flags & NDR_SCALARS) {
10363                 NDR_CHECK(ndr_push_align(ndr, 8));
10364                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10365                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10366                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10367                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10368                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10369                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10370                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10371         }
10372         if (ndr_flags & NDR_BUFFERS) {
10373                 if (r->attribute_name) {
10374                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10375                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10376                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10377                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10378                 }
10379         }
10380         return NDR_ERR_SUCCESS;
10381 }
10382
10383 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
10384 {
10385         uint32_t _ptr_attribute_name;
10386         TALLOC_CTX *_mem_save_attribute_name_0;
10387         if (ndr_flags & NDR_SCALARS) {
10388                 NDR_CHECK(ndr_pull_align(ndr, 8));
10389                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10390                 if (_ptr_attribute_name) {
10391                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10392                 } else {
10393                         r->attribute_name = NULL;
10394                 }
10395                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10396                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10397                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10398                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10399                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10400                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10401         }
10402         if (ndr_flags & NDR_BUFFERS) {
10403                 if (r->attribute_name) {
10404                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10405                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10406                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10407                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10408                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10409                                 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));
10410                         }
10411                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10412                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10413                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10414                 }
10415         }
10416         return NDR_ERR_SUCCESS;
10417 }
10418
10419 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData *r)
10420 {
10421         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData");
10422         ndr->depth++;
10423         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10424         ndr->depth++;
10425         if (r->attribute_name) {
10426                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10427         }
10428         ndr->depth--;
10429         ndr_print_uint32(ndr, "version", r->version);
10430         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10431         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10432         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10433         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10434         ndr->depth--;
10435 }
10436
10437 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10438 {
10439         uint32_t cntr_array_0;
10440         if (ndr_flags & NDR_SCALARS) {
10441                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10442                 NDR_CHECK(ndr_push_align(ndr, 8));
10443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10445                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10446                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10447                 }
10448                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10449         }
10450         if (ndr_flags & NDR_BUFFERS) {
10451                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10452                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10453                 }
10454         }
10455         return NDR_ERR_SUCCESS;
10456 }
10457
10458 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
10459 {
10460         uint32_t cntr_array_0;
10461         TALLOC_CTX *_mem_save_array_0;
10462         if (ndr_flags & NDR_SCALARS) {
10463                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10464                 NDR_CHECK(ndr_pull_align(ndr, 8));
10465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10467                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10468                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10469                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10470                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10471                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10472                 }
10473                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10474                 if (r->array) {
10475                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10476                 }
10477                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10478         }
10479         if (ndr_flags & NDR_BUFFERS) {
10480                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10481                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10482                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10483                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10484                 }
10485                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10486         }
10487         return NDR_ERR_SUCCESS;
10488 }
10489
10490 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10491 {
10492         uint32_t cntr_array_0;
10493         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaDataCtr");
10494         ndr->depth++;
10495         ndr_print_uint32(ndr, "count", r->count);
10496         ndr_print_uint32(ndr, "reserved", r->reserved);
10497         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10498         ndr->depth++;
10499         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10500                 char *idx_0=NULL;
10501                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10502                         ndr_print_drsuapi_DsReplicaObjMetaData(ndr, "array", &r->array[cntr_array_0]);
10503                         free(idx_0);
10504                 }
10505         }
10506         ndr->depth--;
10507         ndr->depth--;
10508 }
10509
10510 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
10511 {
10512         if (ndr_flags & NDR_SCALARS) {
10513                 NDR_CHECK(ndr_push_align(ndr, 5));
10514                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
10515                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10516                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
10517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
10518                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
10519                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10520         }
10521         if (ndr_flags & NDR_BUFFERS) {
10522                 if (r->dsa_obj_dn) {
10523                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10524                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10525                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10526                         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));
10527                 }
10528         }
10529         return NDR_ERR_SUCCESS;
10530 }
10531
10532 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
10533 {
10534         uint32_t _ptr_dsa_obj_dn;
10535         TALLOC_CTX *_mem_save_dsa_obj_dn_0;
10536         if (ndr_flags & NDR_SCALARS) {
10537                 NDR_CHECK(ndr_pull_align(ndr, 5));
10538                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
10539                 if (_ptr_dsa_obj_dn) {
10540                         NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
10541                 } else {
10542                         r->dsa_obj_dn = NULL;
10543                 }
10544                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10545                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
10546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
10547                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
10548                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10549         }
10550         if (ndr_flags & NDR_BUFFERS) {
10551                 if (r->dsa_obj_dn) {
10552                         _mem_save_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10553                         NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
10554                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
10555                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
10556                         if (ndr_get_array_length(ndr, &r->dsa_obj_dn) > ndr_get_array_size(ndr, &r->dsa_obj_dn)) {
10557                                 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));
10558                         }
10559                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t)));
10560                         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));
10561                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
10562                 }
10563         }
10564         return NDR_ERR_SUCCESS;
10565 }
10566
10567 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailure(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailure *r)
10568 {
10569         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailure");
10570         ndr->depth++;
10571         ndr_print_ptr(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10572         ndr->depth++;
10573         if (r->dsa_obj_dn) {
10574                 ndr_print_string(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10575         }
10576         ndr->depth--;
10577         ndr_print_GUID(ndr, "dsa_obj_guid", &r->dsa_obj_guid);
10578         ndr_print_NTTIME(ndr, "first_failure", r->first_failure);
10579         ndr_print_uint32(ndr, "num_failures", r->num_failures);
10580         ndr_print_WERROR(ndr, "last_result", r->last_result);
10581         ndr->depth--;
10582 }
10583
10584 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10585 {
10586         uint32_t cntr_array_0;
10587         if (ndr_flags & NDR_SCALARS) {
10588                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10589                 NDR_CHECK(ndr_push_align(ndr, 5));
10590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10592                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10593                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10594                 }
10595                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10596         }
10597         if (ndr_flags & NDR_BUFFERS) {
10598                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10599                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10600                 }
10601         }
10602         return NDR_ERR_SUCCESS;
10603 }
10604
10605 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10606 {
10607         uint32_t cntr_array_0;
10608         TALLOC_CTX *_mem_save_array_0;
10609         if (ndr_flags & NDR_SCALARS) {
10610                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10611                 NDR_CHECK(ndr_pull_align(ndr, 5));
10612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10614                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10615                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10616                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10617                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10618                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10619                 }
10620                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10621                 if (r->array) {
10622                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10623                 }
10624                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10625         }
10626         if (ndr_flags & NDR_BUFFERS) {
10627                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10628                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10629                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10630                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10631                 }
10632                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10633         }
10634         return NDR_ERR_SUCCESS;
10635 }
10636
10637 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10638 {
10639         uint32_t cntr_array_0;
10640         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailuresCtr");
10641         ndr->depth++;
10642         ndr_print_uint32(ndr, "count", r->count);
10643         ndr_print_uint32(ndr, "reserved", r->reserved);
10644         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10645         ndr->depth++;
10646         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10647                 char *idx_0=NULL;
10648                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10649                         ndr_print_drsuapi_DsReplicaKccDsaFailure(ndr, "array", &r->array[cntr_array_0]);
10650                         free(idx_0);
10651                 }
10652         }
10653         ndr->depth--;
10654         ndr->depth--;
10655 }
10656
10657 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
10658 {
10659         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
10660         return NDR_ERR_SUCCESS;
10661 }
10662
10663 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
10664 {
10665         uint16_t v;
10666         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
10667         *r = v;
10668         return NDR_ERR_SUCCESS;
10669 }
10670
10671 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaOpType r)
10672 {
10673         const char *val = NULL;
10674
10675         switch (r) {
10676                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: val = "DRSUAPI_DS_REPLICA_OP_TYPE_SYNC"; break;
10677                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: val = "DRSUAPI_DS_REPLICA_OP_TYPE_ADD"; break;
10678                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: val = "DRSUAPI_DS_REPLICA_OP_TYPE_DELETE"; break;
10679                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: val = "DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY"; break;
10680                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: val = "DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS"; break;
10681         }
10682         ndr_print_enum(ndr, name, "ENUM", val, r);
10683 }
10684
10685 static enum ndr_err_code ndr_push_drsuapi_DsRplicaOpOptions(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRplicaOpOptions *r)
10686 {
10687         if (ndr_flags & NDR_SCALARS) {
10688                 int level = ndr_push_get_switch_value(ndr, r);
10689                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, level));
10690                 NDR_CHECK(ndr_push_union_align(ndr, 4));
10691                 switch (level) {
10692                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
10693                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, r->sync));
10694                         break; }
10695
10696                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
10697                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->add));
10698                         break; }
10699
10700                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
10701                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->op_delete));
10702                         break; }
10703
10704                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
10705                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->modify));
10706                         break; }
10707
10708                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
10709                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, r->update_refs));
10710                         break; }
10711
10712                         default: {
10713                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
10714                         break; }
10715
10716                 }
10717         }
10718         if (ndr_flags & NDR_BUFFERS) {
10719                 int level = ndr_push_get_switch_value(ndr, r);
10720                 switch (level) {
10721                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10722                         break;
10723
10724                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10725                         break;
10726
10727                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10728                         break;
10729
10730                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10731                         break;
10732
10733                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10734                         break;
10735
10736                         default:
10737                         break;
10738
10739                 }
10740         }
10741         return NDR_ERR_SUCCESS;
10742 }
10743
10744 static enum ndr_err_code ndr_pull_drsuapi_DsRplicaOpOptions(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRplicaOpOptions *r)
10745 {
10746         int level;
10747         uint16_t _level;
10748         level = ndr_pull_get_switch_value(ndr, r);
10749         if (ndr_flags & NDR_SCALARS) {
10750                 NDR_CHECK(ndr_pull_uint1632(ndr, NDR_SCALARS, &_level));
10751                 if (_level != level) {
10752                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
10753                 }
10754                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
10755                 switch (level) {
10756                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: {
10757                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncOptions(ndr, NDR_SCALARS, &r->sync));
10758                         break; }
10759
10760                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: {
10761                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->add));
10762                         break; }
10763
10764                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: {
10765                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->op_delete));
10766                         break; }
10767
10768                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: {
10769                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->modify));
10770                         break; }
10771
10772                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: {
10773                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsOptions(ndr, NDR_SCALARS, &r->update_refs));
10774                         break; }
10775
10776                         default: {
10777                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
10778                         break; }
10779
10780                 }
10781         }
10782         if (ndr_flags & NDR_BUFFERS) {
10783                 switch (level) {
10784                         case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10785                         break;
10786
10787                         case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10788                         break;
10789
10790                         case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10791                         break;
10792
10793                         case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10794                         break;
10795
10796                         case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10797                         break;
10798
10799                         default:
10800                         break;
10801
10802                 }
10803         }
10804         return NDR_ERR_SUCCESS;
10805 }
10806
10807 _PUBLIC_ void ndr_print_drsuapi_DsRplicaOpOptions(struct ndr_print *ndr, const char *name, const union drsuapi_DsRplicaOpOptions *r)
10808 {
10809         int level;
10810         level = ndr_print_get_switch_value(ndr, r);
10811         ndr_print_union(ndr, name, level, "drsuapi_DsRplicaOpOptions");
10812         switch (level) {
10813                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC:
10814                         ndr_print_drsuapi_DsReplicaSyncOptions(ndr, "sync", r->sync);
10815                 break;
10816
10817                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD:
10818                         ndr_print_drsuapi_DsReplicaAddOptions(ndr, "add", r->add);
10819                 break;
10820
10821                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE:
10822                         ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "op_delete", r->op_delete);
10823                 break;
10824
10825                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY:
10826                         ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "modify", r->modify);
10827                 break;
10828
10829                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS:
10830                         ndr_print_drsuapi_DsReplicaUpdateRefsOptions(ndr, "update_refs", r->update_refs);
10831                 break;
10832
10833                 default:
10834                         ndr_print_uint32(ndr, "unknown", r->unknown);
10835                 break;
10836
10837         }
10838 }
10839
10840 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
10841 {
10842         if (ndr_flags & NDR_SCALARS) {
10843                 NDR_CHECK(ndr_push_align(ndr, 5));
10844                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
10845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
10846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
10847                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
10848                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->options, r->operation_type));
10849                 NDR_CHECK(ndr_push_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
10850                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
10851                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
10852                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
10853                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10854                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10855                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10856         }
10857         if (ndr_flags & NDR_BUFFERS) {
10858                 if (r->nc_dn) {
10859                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10860                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10861                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10862                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10863                 }
10864                 if (r->remote_dsa_obj_dn) {
10865                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10866                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10867                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10868                         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));
10869                 }
10870                 if (r->remote_dsa_address) {
10871                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10872                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10873                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10874                         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));
10875                 }
10876         }
10877         return NDR_ERR_SUCCESS;
10878 }
10879
10880 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
10881 {
10882         uint32_t _ptr_nc_dn;
10883         TALLOC_CTX *_mem_save_nc_dn_0;
10884         uint32_t _ptr_remote_dsa_obj_dn;
10885         TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
10886         uint32_t _ptr_remote_dsa_address;
10887         TALLOC_CTX *_mem_save_remote_dsa_address_0;
10888         if (ndr_flags & NDR_SCALARS) {
10889                 NDR_CHECK(ndr_pull_align(ndr, 5));
10890                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
10891                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
10892                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
10893                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
10894                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->options, r->operation_type));
10895                 NDR_CHECK(ndr_pull_drsuapi_DsRplicaOpOptions(ndr, NDR_SCALARS, &r->options));
10896                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
10897                 if (_ptr_nc_dn) {
10898                         NDR_PULL_ALLOC(ndr, r->nc_dn);
10899                 } else {
10900                         r->nc_dn = NULL;
10901                 }
10902                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_obj_dn));
10903                 if (_ptr_remote_dsa_obj_dn) {
10904                         NDR_PULL_ALLOC(ndr, r->remote_dsa_obj_dn);
10905                 } else {
10906                         r->remote_dsa_obj_dn = NULL;
10907                 }
10908                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_address));
10909                 if (_ptr_remote_dsa_address) {
10910                         NDR_PULL_ALLOC(ndr, r->remote_dsa_address);
10911                 } else {
10912                         r->remote_dsa_address = NULL;
10913                 }
10914                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10915                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10916                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10917         }
10918         if (ndr_flags & NDR_BUFFERS) {
10919                 if (r->nc_dn) {
10920                         _mem_save_nc_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10921                         NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
10922                         NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
10923                         NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
10924                         if (ndr_get_array_length(ndr, &r->nc_dn) > ndr_get_array_size(ndr, &r->nc_dn)) {
10925                                 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));
10926                         }
10927                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t)));
10928                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t), CH_UTF16));
10929                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
10930                 }
10931                 if (r->remote_dsa_obj_dn) {
10932                         _mem_save_remote_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10933                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
10934                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
10935                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
10936                         if (ndr_get_array_length(ndr, &r->remote_dsa_obj_dn) > ndr_get_array_size(ndr, &r->remote_dsa_obj_dn)) {
10937                                 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));
10938                         }
10939                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t)));
10940                         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));
10941                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
10942                 }
10943                 if (r->remote_dsa_address) {
10944                         _mem_save_remote_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10945                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
10946                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
10947                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
10948                         if (ndr_get_array_length(ndr, &r->remote_dsa_address) > ndr_get_array_size(ndr, &r->remote_dsa_address)) {
10949                                 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));
10950                         }
10951                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t)));
10952                         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));
10953                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
10954                 }
10955         }
10956         return NDR_ERR_SUCCESS;
10957 }
10958
10959 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOp *r)
10960 {
10961         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOp");
10962         ndr->depth++;
10963         ndr_print_NTTIME(ndr, "operation_start", r->operation_start);
10964         ndr_print_uint32(ndr, "serial_num", r->serial_num);
10965         ndr_print_uint32(ndr, "priority", r->priority);
10966         ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
10967         ndr_print_set_switch_value(ndr, &r->options, r->operation_type);
10968         ndr_print_drsuapi_DsRplicaOpOptions(ndr, "options", &r->options);
10969         ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
10970         ndr->depth++;
10971         if (r->nc_dn) {
10972                 ndr_print_string(ndr, "nc_dn", r->nc_dn);
10973         }
10974         ndr->depth--;
10975         ndr_print_ptr(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10976         ndr->depth++;
10977         if (r->remote_dsa_obj_dn) {
10978                 ndr_print_string(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10979         }
10980         ndr->depth--;
10981         ndr_print_ptr(ndr, "remote_dsa_address", r->remote_dsa_address);
10982         ndr->depth++;
10983         if (r->remote_dsa_address) {
10984                 ndr_print_string(ndr, "remote_dsa_address", r->remote_dsa_address);
10985         }
10986         ndr->depth--;
10987         ndr_print_GUID(ndr, "nc_obj_guid", &r->nc_obj_guid);
10988         ndr_print_GUID(ndr, "remote_dsa_obj_guid", &r->remote_dsa_obj_guid);
10989         ndr->depth--;
10990 }
10991
10992 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOpCtr *r)
10993 {
10994         uint32_t cntr_array_0;
10995         if (ndr_flags & NDR_SCALARS) {
10996                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10997                 NDR_CHECK(ndr_push_align(ndr, 5));
10998                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
10999                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11000                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11001                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11002                 }
11003                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
11004         }
11005         if (ndr_flags & NDR_BUFFERS) {
11006                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11007                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11008                 }
11009         }
11010         return NDR_ERR_SUCCESS;
11011 }
11012
11013 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
11014 {
11015         uint32_t cntr_array_0;
11016         TALLOC_CTX *_mem_save_array_0;
11017         if (ndr_flags & NDR_SCALARS) {
11018                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11019                 NDR_CHECK(ndr_pull_align(ndr, 5));
11020                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
11021                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11022                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11023                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11024                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11025                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11026                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11027                 }
11028                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11029                 if (r->array) {
11030                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11031                 }
11032                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
11033         }
11034         if (ndr_flags & NDR_BUFFERS) {
11035                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11036                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11037                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11038                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11039                 }
11040                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11041         }
11042         return NDR_ERR_SUCCESS;
11043 }
11044
11045 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOpCtr *r)
11046 {
11047         uint32_t cntr_array_0;
11048         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOpCtr");
11049         ndr->depth++;
11050         ndr_print_NTTIME(ndr, "time", r->time);
11051         ndr_print_uint32(ndr, "count", r->count);
11052         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11053         ndr->depth++;
11054         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11055                 char *idx_0=NULL;
11056                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11057                         ndr_print_drsuapi_DsReplicaOp(ndr, "array", &r->array[cntr_array_0]);
11058                         free(idx_0);
11059                 }
11060         }
11061         ndr->depth--;
11062         ndr->depth--;
11063 }
11064
11065 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData *r)
11066 {
11067         if (ndr_flags & NDR_SCALARS) {
11068                 NDR_CHECK(ndr_push_align(ndr, 8));
11069                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11070                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11072                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11073                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11074                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11076                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11077                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11078                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11079                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11080                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11081         }
11082         if (ndr_flags & NDR_BUFFERS) {
11083                 if (r->attribute_name) {
11084                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11085                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11086                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11087                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11088                 }
11089                 if (r->object_dn) {
11090                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11091                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11092                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11093                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11094                 }
11095                 if (r->binary) {
11096                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11097                 }
11098         }
11099         return NDR_ERR_SUCCESS;
11100 }
11101
11102 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
11103 {
11104         uint32_t _ptr_attribute_name;
11105         TALLOC_CTX *_mem_save_attribute_name_0;
11106         uint32_t _ptr_object_dn;
11107         TALLOC_CTX *_mem_save_object_dn_0;
11108         uint32_t _ptr_binary;
11109         TALLOC_CTX *_mem_save_binary_0;
11110         if (ndr_flags & NDR_SCALARS) {
11111                 NDR_CHECK(ndr_pull_align(ndr, 8));
11112                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11113                 if (_ptr_attribute_name) {
11114                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11115                 } else {
11116                         r->attribute_name = NULL;
11117                 }
11118                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11119                 if (_ptr_object_dn) {
11120                         NDR_PULL_ALLOC(ndr, r->object_dn);
11121                 } else {
11122                         r->object_dn = NULL;
11123                 }
11124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11125                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11126                 if (_ptr_binary) {
11127                         NDR_PULL_ALLOC(ndr, r->binary);
11128                 } else {
11129                         r->binary = NULL;
11130                 }
11131                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11132                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11134                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11135                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11136                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11137                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11138                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11139         }
11140         if (ndr_flags & NDR_BUFFERS) {
11141                 if (r->attribute_name) {
11142                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11143                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11144                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11145                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11146                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11147                                 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));
11148                         }
11149                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11150                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11151                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11152                 }
11153                 if (r->object_dn) {
11154                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11155                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11156                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11157                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11158                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11159                                 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));
11160                         }
11161                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11162                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11163                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11164                 }
11165                 if (r->binary) {
11166                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11167                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11168                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11169                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11170                 }
11171         }
11172         return NDR_ERR_SUCCESS;
11173 }
11174
11175 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData *r)
11176 {
11177         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData");
11178         ndr->depth++;
11179         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11180         ndr->depth++;
11181         if (r->attribute_name) {
11182                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11183         }
11184         ndr->depth--;
11185         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11186         ndr->depth++;
11187         if (r->object_dn) {
11188                 ndr_print_string(ndr, "object_dn", r->object_dn);
11189         }
11190         ndr->depth--;
11191         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);
11192         ndr_print_ptr(ndr, "binary", r->binary);
11193         ndr->depth++;
11194         if (r->binary) {
11195                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11196         }
11197         ndr->depth--;
11198         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11199         ndr_print_NTTIME(ndr, "created", r->created);
11200         ndr_print_uint32(ndr, "version", r->version);
11201         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11202         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11203         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11204         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11205         ndr->depth--;
11206 }
11207
11208 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
11209 {
11210         uint32_t cntr_array_0;
11211         if (ndr_flags & NDR_SCALARS) {
11212                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11213                 NDR_CHECK(ndr_push_align(ndr, 8));
11214                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11215                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11216                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11217                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11218                 }
11219                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11220         }
11221         if (ndr_flags & NDR_BUFFERS) {
11222                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11223                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11224                 }
11225         }
11226         return NDR_ERR_SUCCESS;
11227 }
11228
11229 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
11230 {
11231         uint32_t cntr_array_0;
11232         TALLOC_CTX *_mem_save_array_0;
11233         if (ndr_flags & NDR_SCALARS) {
11234                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11235                 NDR_CHECK(ndr_pull_align(ndr, 8));
11236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11237                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11238                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11239                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11240                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11241                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11242                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11243                 }
11244                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11245                 if (r->array) {
11246                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11247                 }
11248                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11249         }
11250         if (ndr_flags & NDR_BUFFERS) {
11251                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11252                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11253                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11254                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11255                 }
11256                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11257         }
11258         return NDR_ERR_SUCCESS;
11259 }
11260
11261 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
11262 {
11263         uint32_t cntr_array_0;
11264         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaDataCtr");
11265         ndr->depth++;
11266         ndr_print_uint32(ndr, "count", r->count);
11267         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11268         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11269         ndr->depth++;
11270         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11271                 char *idx_0=NULL;
11272                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11273                         ndr_print_drsuapi_DsReplicaAttrValMetaData(ndr, "array", &r->array[cntr_array_0]);
11274                         free(idx_0);
11275                 }
11276         }
11277         ndr->depth--;
11278         ndr->depth--;
11279 }
11280
11281 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2Ctr *r)
11282 {
11283         uint32_t cntr_array_0;
11284         if (ndr_flags & NDR_SCALARS) {
11285                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11286                 NDR_CHECK(ndr_push_align(ndr, 8));
11287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11288                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11289                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11290                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11291                 }
11292                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11293         }
11294         if (ndr_flags & NDR_BUFFERS) {
11295         }
11296         return NDR_ERR_SUCCESS;
11297 }
11298
11299 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
11300 {
11301         uint32_t cntr_array_0;
11302         TALLOC_CTX *_mem_save_array_0;
11303         if (ndr_flags & NDR_SCALARS) {
11304                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11305                 NDR_CHECK(ndr_pull_align(ndr, 8));
11306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11307                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11308                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11309                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11310                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11311                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11312                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11313                 }
11314                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11315                 if (r->array) {
11316                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11317                 }
11318                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11319         }
11320         if (ndr_flags & NDR_BUFFERS) {
11321         }
11322         return NDR_ERR_SUCCESS;
11323 }
11324
11325 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2Ctr *r)
11326 {
11327         uint32_t cntr_array_0;
11328         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2Ctr");
11329         ndr->depth++;
11330         ndr_print_uint32(ndr, "count", r->count);
11331         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11332         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11333         ndr->depth++;
11334         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11335                 char *idx_0=NULL;
11336                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11337                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "array", &r->array[cntr_array_0]);
11338                         free(idx_0);
11339                 }
11340         }
11341         ndr->depth--;
11342         ndr->depth--;
11343 }
11344
11345 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3 *r)
11346 {
11347         if (ndr_flags & NDR_SCALARS) {
11348                 NDR_CHECK(ndr_push_align(ndr, 8));
11349                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11350                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
11351                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
11352                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
11353                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11354         }
11355         if (ndr_flags & NDR_BUFFERS) {
11356                 if (r->source_dsa_obj_dn) {
11357                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11358                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11359                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11360                         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));
11361                 }
11362         }
11363         return NDR_ERR_SUCCESS;
11364 }
11365
11366 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
11367 {
11368         uint32_t _ptr_source_dsa_obj_dn;
11369         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
11370         if (ndr_flags & NDR_SCALARS) {
11371                 NDR_CHECK(ndr_pull_align(ndr, 8));
11372                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11373                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
11374                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
11375                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
11376                 if (_ptr_source_dsa_obj_dn) {
11377                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
11378                 } else {
11379                         r->source_dsa_obj_dn = NULL;
11380                 }
11381                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11382         }
11383         if (ndr_flags & NDR_BUFFERS) {
11384                 if (r->source_dsa_obj_dn) {
11385                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11386                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
11387                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
11388                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
11389                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
11390                                 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));
11391                         }
11392                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
11393                         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));
11394                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
11395                 }
11396         }
11397         return NDR_ERR_SUCCESS;
11398 }
11399
11400 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3 *r)
11401 {
11402         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3");
11403         ndr->depth++;
11404         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
11405         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
11406         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
11407         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11408         ndr->depth++;
11409         if (r->source_dsa_obj_dn) {
11410                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11411         }
11412         ndr->depth--;
11413         ndr->depth--;
11414 }
11415
11416 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3Ctr *r)
11417 {
11418         uint32_t cntr_array_0;
11419         if (ndr_flags & NDR_SCALARS) {
11420                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11421                 NDR_CHECK(ndr_push_align(ndr, 8));
11422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11423                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11424                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11425                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11426                 }
11427                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11428         }
11429         if (ndr_flags & NDR_BUFFERS) {
11430                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11431                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11432                 }
11433         }
11434         return NDR_ERR_SUCCESS;
11435 }
11436
11437 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
11438 {
11439         uint32_t cntr_array_0;
11440         TALLOC_CTX *_mem_save_array_0;
11441         if (ndr_flags & NDR_SCALARS) {
11442                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11443                 NDR_CHECK(ndr_pull_align(ndr, 8));
11444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11445                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11446                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11447                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11448                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11449                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11450                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11451                 }
11452                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11453                 if (r->array) {
11454                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11455                 }
11456                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11457         }
11458         if (ndr_flags & NDR_BUFFERS) {
11459                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11460                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11461                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11462                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11463                 }
11464                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11465         }
11466         return NDR_ERR_SUCCESS;
11467 }
11468
11469 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3Ctr *r)
11470 {
11471         uint32_t cntr_array_0;
11472         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3Ctr");
11473         ndr->depth++;
11474         ndr_print_uint32(ndr, "count", r->count);
11475         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11476         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11477         ndr->depth++;
11478         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11479                 char *idx_0=NULL;
11480                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11481                         ndr_print_drsuapi_DsReplicaCursor3(ndr, "array", &r->array[cntr_array_0]);
11482                         free(idx_0);
11483                 }
11484         }
11485         ndr->depth--;
11486         ndr->depth--;
11487 }
11488
11489 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2 *r)
11490 {
11491         if (ndr_flags & NDR_SCALARS) {
11492                 NDR_CHECK(ndr_push_align(ndr, 8));
11493                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11494                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11495                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11496                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11497                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11498                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11499                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11500                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11501         }
11502         if (ndr_flags & NDR_BUFFERS) {
11503                 if (r->attribute_name) {
11504                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11505                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11506                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11507                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11508                 }
11509                 if (r->originating_dsa_dn) {
11510                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11511                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11512                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11513                         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));
11514                 }
11515         }
11516         return NDR_ERR_SUCCESS;
11517 }
11518
11519 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
11520 {
11521         uint32_t _ptr_attribute_name;
11522         TALLOC_CTX *_mem_save_attribute_name_0;
11523         uint32_t _ptr_originating_dsa_dn;
11524         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11525         if (ndr_flags & NDR_SCALARS) {
11526                 NDR_CHECK(ndr_pull_align(ndr, 8));
11527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11528                 if (_ptr_attribute_name) {
11529                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11530                 } else {
11531                         r->attribute_name = NULL;
11532                 }
11533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11534                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11535                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11536                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11537                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11538                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11539                 if (_ptr_originating_dsa_dn) {
11540                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11541                 } else {
11542                         r->originating_dsa_dn = NULL;
11543                 }
11544                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11545         }
11546         if (ndr_flags & NDR_BUFFERS) {
11547                 if (r->attribute_name) {
11548                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11549                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11550                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11551                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11552                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11553                                 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));
11554                         }
11555                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11556                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11558                 }
11559                 if (r->originating_dsa_dn) {
11560                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11561                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11562                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11563                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11564                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11565                                 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));
11566                         }
11567                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11568                         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));
11569                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11570                 }
11571         }
11572         return NDR_ERR_SUCCESS;
11573 }
11574
11575 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2 *r)
11576 {
11577         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2");
11578         ndr->depth++;
11579         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11580         ndr->depth++;
11581         if (r->attribute_name) {
11582                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11583         }
11584         ndr->depth--;
11585         ndr_print_uint32(ndr, "version", r->version);
11586         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11587         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11588         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11589         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11590         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11591         ndr->depth++;
11592         if (r->originating_dsa_dn) {
11593                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11594         }
11595         ndr->depth--;
11596         ndr->depth--;
11597 }
11598
11599 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11600 {
11601         uint32_t cntr_array_0;
11602         if (ndr_flags & NDR_SCALARS) {
11603                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11604                 NDR_CHECK(ndr_push_align(ndr, 8));
11605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11606                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11607                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11608                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11609                 }
11610                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11611         }
11612         if (ndr_flags & NDR_BUFFERS) {
11613                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11614                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11615                 }
11616         }
11617         return NDR_ERR_SUCCESS;
11618 }
11619
11620 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11621 {
11622         uint32_t cntr_array_0;
11623         TALLOC_CTX *_mem_save_array_0;
11624         if (ndr_flags & NDR_SCALARS) {
11625                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11626                 NDR_CHECK(ndr_pull_align(ndr, 8));
11627                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11628                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11629                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11630                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11631                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11632                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11633                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11634                 }
11635                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11636                 if (r->array) {
11637                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11638                 }
11639                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11640         }
11641         if (ndr_flags & NDR_BUFFERS) {
11642                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11643                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11644                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11645                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11646                 }
11647                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11648         }
11649         return NDR_ERR_SUCCESS;
11650 }
11651
11652 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11653 {
11654         uint32_t cntr_array_0;
11655         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2Ctr");
11656         ndr->depth++;
11657         ndr_print_uint32(ndr, "count", r->count);
11658         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11659         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11660         ndr->depth++;
11661         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11662                 char *idx_0=NULL;
11663                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11664                         ndr_print_drsuapi_DsReplicaObjMetaData2(ndr, "array", &r->array[cntr_array_0]);
11665                         free(idx_0);
11666                 }
11667         }
11668         ndr->depth--;
11669         ndr->depth--;
11670 }
11671
11672 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11673 {
11674         if (ndr_flags & NDR_SCALARS) {
11675                 NDR_CHECK(ndr_push_align(ndr, 8));
11676                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11677                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11678                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11680                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11681                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11683                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11684                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11685                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11686                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11687                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11688                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11689         }
11690         if (ndr_flags & NDR_BUFFERS) {
11691                 if (r->attribute_name) {
11692                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11693                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11694                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11695                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11696                 }
11697                 if (r->object_dn) {
11698                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11699                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11700                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11701                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11702                 }
11703                 if (r->binary) {
11704                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11705                 }
11706                 if (r->originating_dsa_dn) {
11707                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11708                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11709                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11710                         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));
11711                 }
11712         }
11713         return NDR_ERR_SUCCESS;
11714 }
11715
11716 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
11717 {
11718         uint32_t _ptr_attribute_name;
11719         TALLOC_CTX *_mem_save_attribute_name_0;
11720         uint32_t _ptr_object_dn;
11721         TALLOC_CTX *_mem_save_object_dn_0;
11722         uint32_t _ptr_binary;
11723         TALLOC_CTX *_mem_save_binary_0;
11724         uint32_t _ptr_originating_dsa_dn;
11725         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11726         if (ndr_flags & NDR_SCALARS) {
11727                 NDR_CHECK(ndr_pull_align(ndr, 8));
11728                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11729                 if (_ptr_attribute_name) {
11730                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11731                 } else {
11732                         r->attribute_name = NULL;
11733                 }
11734                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11735                 if (_ptr_object_dn) {
11736                         NDR_PULL_ALLOC(ndr, r->object_dn);
11737                 } else {
11738                         r->object_dn = NULL;
11739                 }
11740                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11741                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11742                 if (_ptr_binary) {
11743                         NDR_PULL_ALLOC(ndr, r->binary);
11744                 } else {
11745                         r->binary = NULL;
11746                 }
11747                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11748                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11749                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11750                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11751                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11752                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11753                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11754                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11755                 if (_ptr_originating_dsa_dn) {
11756                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11757                 } else {
11758                         r->originating_dsa_dn = NULL;
11759                 }
11760                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11761         }
11762         if (ndr_flags & NDR_BUFFERS) {
11763                 if (r->attribute_name) {
11764                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11765                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11766                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11767                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11768                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11769                                 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));
11770                         }
11771                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11772                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11773                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11774                 }
11775                 if (r->object_dn) {
11776                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11777                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11778                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11779                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11780                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11781                                 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));
11782                         }
11783                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11784                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11785                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11786                 }
11787                 if (r->binary) {
11788                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11789                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11790                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11791                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11792                 }
11793                 if (r->originating_dsa_dn) {
11794                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11795                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11796                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11797                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11798                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11799                                 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));
11800                         }
11801                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11802                         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));
11803                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11804                 }
11805         }
11806         return NDR_ERR_SUCCESS;
11807 }
11808
11809 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11810 {
11811         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2");
11812         ndr->depth++;
11813         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11814         ndr->depth++;
11815         if (r->attribute_name) {
11816                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11817         }
11818         ndr->depth--;
11819         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11820         ndr->depth++;
11821         if (r->object_dn) {
11822                 ndr_print_string(ndr, "object_dn", r->object_dn);
11823         }
11824         ndr->depth--;
11825         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);
11826         ndr_print_ptr(ndr, "binary", r->binary);
11827         ndr->depth++;
11828         if (r->binary) {
11829                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11830         }
11831         ndr->depth--;
11832         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11833         ndr_print_NTTIME(ndr, "created", r->created);
11834         ndr_print_uint32(ndr, "version", r->version);
11835         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11836         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11837         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11838         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11839         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11840         ndr->depth++;
11841         if (r->originating_dsa_dn) {
11842                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11843         }
11844         ndr->depth--;
11845         ndr->depth--;
11846 }
11847
11848 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11849 {
11850         uint32_t cntr_array_0;
11851         if (ndr_flags & NDR_SCALARS) {
11852                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11853                 NDR_CHECK(ndr_push_align(ndr, 8));
11854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11855                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->enumeration_context));
11856                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11857                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11858                 }
11859                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11860         }
11861         if (ndr_flags & NDR_BUFFERS) {
11862                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11863                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11864                 }
11865         }
11866         return NDR_ERR_SUCCESS;
11867 }
11868
11869 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11870 {
11871         uint32_t cntr_array_0;
11872         TALLOC_CTX *_mem_save_array_0;
11873         if (ndr_flags & NDR_SCALARS) {
11874                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11875                 NDR_CHECK(ndr_pull_align(ndr, 8));
11876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11877                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->enumeration_context));
11878                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11879                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11880                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11881                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11882                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11883                 }
11884                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11885                 if (r->array) {
11886                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11887                 }
11888                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11889         }
11890         if (ndr_flags & NDR_BUFFERS) {
11891                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11892                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11893                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11894                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11895                 }
11896                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11897         }
11898         return NDR_ERR_SUCCESS;
11899 }
11900
11901 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11902 {
11903         uint32_t cntr_array_0;
11904         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2Ctr");
11905         ndr->depth++;
11906         ndr_print_uint32(ndr, "count", r->count);
11907         ndr_print_int32(ndr, "enumeration_context", r->enumeration_context);
11908         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11909         ndr->depth++;
11910         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11911                 char *idx_0=NULL;
11912                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11913                         ndr_print_drsuapi_DsReplicaAttrValMetaData2(ndr, "array", &r->array[cntr_array_0]);
11914                         free(idx_0);
11915                 }
11916         }
11917         ndr->depth--;
11918         ndr->depth--;
11919 }
11920
11921 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04 *r)
11922 {
11923         if (ndr_flags & NDR_SCALARS) {
11924                 NDR_CHECK(ndr_push_align(ndr, 8));
11925                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u1));
11926                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11927                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11928                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11929                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->bind_time));
11930                 {
11931                         uint32_t _flags_save_ipv4address = ndr->flags;
11932                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11933                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
11934                         ndr->flags = _flags_save_ipv4address;
11935                 }
11936                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11937                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11938         }
11939         if (ndr_flags & NDR_BUFFERS) {
11940         }
11941         return NDR_ERR_SUCCESS;
11942 }
11943
11944 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04 *r)
11945 {
11946         if (ndr_flags & NDR_SCALARS) {
11947                 NDR_CHECK(ndr_pull_align(ndr, 8));
11948                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u1));
11949                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11951                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11952                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->bind_time));
11953                 {
11954                         uint32_t _flags_save_ipv4address = ndr->flags;
11955                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11956                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
11957                         ndr->flags = _flags_save_ipv4address;
11958                 }
11959                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11960                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11961         }
11962         if (ndr_flags & NDR_BUFFERS) {
11963         }
11964         return NDR_ERR_SUCCESS;
11965 }
11966
11967 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04 *r)
11968 {
11969         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04");
11970         ndr->depth++;
11971         ndr_print_hyper(ndr, "u1", r->u1);
11972         ndr_print_uint32(ndr, "u2", r->u2);
11973         ndr_print_uint32(ndr, "u3", r->u3);
11974         ndr_print_GUID(ndr, "bind_guid", &r->bind_guid);
11975         ndr_print_NTTIME_1sec(ndr, "bind_time", r->bind_time);
11976         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
11977         ndr_print_uint32(ndr, "u5", r->u5);
11978         ndr->depth--;
11979 }
11980
11981 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04Ctr *r)
11982 {
11983         uint32_t cntr_array_0;
11984         if (ndr_flags & NDR_SCALARS) {
11985                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11986                 NDR_CHECK(ndr_push_align(ndr, 8));
11987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11988                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11989                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11990                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11991                 }
11992                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11993         }
11994         if (ndr_flags & NDR_BUFFERS) {
11995         }
11996         return NDR_ERR_SUCCESS;
11997 }
11998
11999 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
12000 {
12001         uint32_t cntr_array_0;
12002         TALLOC_CTX *_mem_save_array_0;
12003         if (ndr_flags & NDR_SCALARS) {
12004                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
12005                 NDR_CHECK(ndr_pull_align(ndr, 8));
12006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
12007                 if (r->count > 10000) {
12008                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12009                 }
12010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
12011                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
12012                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12013                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12014                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12015                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
12016                 }
12017                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12018                 if (r->array) {
12019                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
12020                 }
12021                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12022         }
12023         if (ndr_flags & NDR_BUFFERS) {
12024         }
12025         return NDR_ERR_SUCCESS;
12026 }
12027
12028 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04Ctr *r)
12029 {
12030         uint32_t cntr_array_0;
12031         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04Ctr");
12032         ndr->depth++;
12033         ndr_print_uint32(ndr, "count", r->count);
12034         ndr_print_uint32(ndr, "reserved", r->reserved);
12035         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
12036         ndr->depth++;
12037         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
12038                 char *idx_0=NULL;
12039                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
12040                         ndr_print_drsuapi_DsReplicaConnection04(ndr, "array", &r->array[cntr_array_0]);
12041                         free(idx_0);
12042                 }
12043         }
12044         ndr->depth--;
12045         ndr->depth--;
12046 }
12047
12048 static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06 *r)
12049 {
12050         if (ndr_flags & NDR_SCALARS) {
12051                 NDR_CHECK(ndr_push_align(ndr, 8));
12052                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str1));
12053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u1));
12054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
12055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
12056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u4));
12057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
12058                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
12059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
12060                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12061         }
12062         if (ndr_flags & NDR_BUFFERS) {
12063                 if (r->str1) {
12064                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
12065                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
12066                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
12067                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12068                 }
12069         }
12070         return NDR_ERR_SUCCESS;
12071 }
12072
12073 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
12074 {
12075         uint32_t _ptr_str1;
12076         TALLOC_CTX *_mem_save_str1_0;
12077         if (ndr_flags & NDR_SCALARS) {
12078                 NDR_CHECK(ndr_pull_align(ndr, 8));
12079                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str1));
12080                 if (_ptr_str1) {
12081                         NDR_PULL_ALLOC(ndr, r->str1);
12082                 } else {
12083                         r->str1 = NULL;
12084                 }
12085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
12086                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
12087                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
12088                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u4));
12089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
12090                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
12091                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
12092                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12093         }
12094         if (ndr_flags & NDR_BUFFERS) {
12095                 if (r->str1) {
12096                         _mem_save_str1_0 = NDR_PULL_GET_MEM_CTX(ndr);
12097                         NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
12098                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
12099                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
12100                         if (ndr_get_array_length(ndr, &r->str1) > ndr_get_array_size(ndr, &r->str1)) {
12101                                 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));
12102                         }
12103                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t)));
12104                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t), CH_UTF16));
12105                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
12106                 }
12107         }
12108         return NDR_ERR_SUCCESS;
12109 }
12110
12111 _PUBLIC_ void ndr_print_drsuapi_DsReplica06(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06 *r)
12112 {
12113         ndr_print_struct(ndr, name, "drsuapi_DsReplica06");
12114         ndr->depth++;
12115         ndr_print_ptr(ndr, "str1", r->str1);
12116         ndr->depth++;
12117         if (r->str1) {
12118                 ndr_print_string(ndr, "str1", r->str1);
12119         }
12120         ndr->depth--;
12121         ndr_print_uint32(ndr, "u1", r->u1);
12122         ndr_print_uint32(ndr, "u2", r->u2);
12123         ndr_print_uint32(ndr, "u3", r->u3);
12124         ndr_print_uint32(ndr, "u4", r->u4);
12125         ndr_print_uint32(ndr, "u5", r->u5);
12126         ndr_print_hyper(ndr, "u6", r->u6);
12127         ndr_print_uint32(ndr, "u7", r->u7);
12128         ndr->depth--;
12129 }
12130
12131 static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06Ctr *r)
12132 {
12133         uint32_t cntr_array_0;
12134         if (ndr_flags & NDR_SCALARS) {
12135                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
12136                 NDR_CHECK(ndr_push_align(ndr, 8));
12137                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
12138                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
12139                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12140                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
12141                 }
12142                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
12143         }
12144         if (ndr_flags & NDR_BUFFERS) {
12145                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12146                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
12147                 }
12148         }
12149         return NDR_ERR_SUCCESS;
12150 }
12151
12152 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *r)
12153 {
12154         uint32_t cntr_array_0;
12155         TALLOC_CTX *_mem_save_array_0;
12156         if (ndr_flags & NDR_SCALARS) {
12157                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
12158                 NDR_CHECK(ndr_pull_align(ndr, 8));
12159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
12160                 if (r->count > 256) {
12161                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12162                 }
12163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
12164                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
12165                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12166                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12167                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12168                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
12169                 }
12170                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12171                 if (r->array) {
12172                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
12173                 }
12174                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
12175         }
12176         if (ndr_flags & NDR_BUFFERS) {
12177                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12178                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
12179                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
12180                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
12181                 }
12182                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
12183         }
12184         return NDR_ERR_SUCCESS;
12185 }
12186
12187 _PUBLIC_ void ndr_print_drsuapi_DsReplica06Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06Ctr *r)
12188 {
12189         uint32_t cntr_array_0;
12190         ndr_print_struct(ndr, name, "drsuapi_DsReplica06Ctr");
12191         ndr->depth++;
12192         ndr_print_uint32(ndr, "count", r->count);
12193         ndr_print_uint32(ndr, "reserved", r->reserved);
12194         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
12195         ndr->depth++;
12196         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
12197                 char *idx_0=NULL;
12198                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
12199                         ndr_print_drsuapi_DsReplica06(ndr, "array", &r->array[cntr_array_0]);
12200                         free(idx_0);
12201                 }
12202         }
12203         ndr->depth--;
12204         ndr->depth--;
12205 }
12206
12207 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaInfo *r)
12208 {
12209         if (ndr_flags & NDR_SCALARS) {
12210                 int level = ndr_push_get_switch_value(ndr, r);
12211                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
12212                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12213                 switch (level) {
12214                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12215                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
12216                         break; }
12217
12218                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12219                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors));
12220                         break; }
12221
12222                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12223                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata));
12224                         break; }
12225
12226                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12227                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connectfailures));
12228                         break; }
12229
12230                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12231                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linkfailures));
12232                         break; }
12233
12234                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12235                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pendingops));
12236                         break; }
12237
12238                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12239                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata));
12240                         break; }
12241
12242                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12243                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors2));
12244                         break; }
12245
12246                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12247                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors3));
12248                         break; }
12249
12250                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12251                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata2));
12252                         break; }
12253
12254                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12255                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata2));
12256                         break; }
12257
12258                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
12259                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours02));
12260                         break; }
12261
12262                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
12263                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connections04));
12264                         break; }
12265
12266                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
12267                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors05));
12268                         break; }
12269
12270                         case DRSUAPI_DS_REPLICA_INFO_06: {
12271                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->i06));
12272                         break; }
12273
12274                         default:
12275                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12276                 }
12277         }
12278         if (ndr_flags & NDR_BUFFERS) {
12279                 int level = ndr_push_get_switch_value(ndr, r);
12280                 switch (level) {
12281                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12282                                 if (r->neighbours) {
12283                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12284                                 }
12285                         break;
12286
12287                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12288                                 if (r->cursors) {
12289                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12290                                 }
12291                         break;
12292
12293                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12294                                 if (r->objmetadata) {
12295                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12296                                 }
12297                         break;
12298
12299                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12300                                 if (r->connectfailures) {
12301                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12302                                 }
12303                         break;
12304
12305                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12306                                 if (r->linkfailures) {
12307                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12308                                 }
12309                         break;
12310
12311                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12312                                 if (r->pendingops) {
12313                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12314                                 }
12315                         break;
12316
12317                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12318                                 if (r->attrvalmetadata) {
12319                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12320                                 }
12321                         break;
12322
12323                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12324                                 if (r->cursors2) {
12325                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12326                                 }
12327                         break;
12328
12329                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12330                                 if (r->cursors3) {
12331                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12332                                 }
12333                         break;
12334
12335                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12336                                 if (r->objmetadata2) {
12337                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12338                                 }
12339                         break;
12340
12341                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12342                                 if (r->attrvalmetadata2) {
12343                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12344                                 }
12345                         break;
12346
12347                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12348                                 if (r->neighbours02) {
12349                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12350                                 }
12351                         break;
12352
12353                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12354                                 if (r->connections04) {
12355                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12356                                 }
12357                         break;
12358
12359                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12360                                 if (r->cursors05) {
12361                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12362                                 }
12363                         break;
12364
12365                         case DRSUAPI_DS_REPLICA_INFO_06:
12366                                 if (r->i06) {
12367                                         NDR_CHECK(ndr_push_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12368                                 }
12369                         break;
12370
12371                         default:
12372                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12373                 }
12374         }
12375         return NDR_ERR_SUCCESS;
12376 }
12377
12378 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaInfo *r)
12379 {
12380         int level;
12381         uint32_t _level;
12382         TALLOC_CTX *_mem_save_neighbours_0;
12383         TALLOC_CTX *_mem_save_cursors_0;
12384         TALLOC_CTX *_mem_save_objmetadata_0;
12385         TALLOC_CTX *_mem_save_connectfailures_0;
12386         TALLOC_CTX *_mem_save_linkfailures_0;
12387         TALLOC_CTX *_mem_save_pendingops_0;
12388         TALLOC_CTX *_mem_save_attrvalmetadata_0;
12389         TALLOC_CTX *_mem_save_cursors2_0;
12390         TALLOC_CTX *_mem_save_cursors3_0;
12391         TALLOC_CTX *_mem_save_objmetadata2_0;
12392         TALLOC_CTX *_mem_save_attrvalmetadata2_0;
12393         TALLOC_CTX *_mem_save_neighbours02_0;
12394         TALLOC_CTX *_mem_save_connections04_0;
12395         TALLOC_CTX *_mem_save_cursors05_0;
12396         TALLOC_CTX *_mem_save_i06_0;
12397         level = ndr_pull_get_switch_value(ndr, r);
12398         if (ndr_flags & NDR_SCALARS) {
12399                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12400                 if (_level != level) {
12401                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12402                 }
12403                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12404                 switch (level) {
12405                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12406                                 uint32_t _ptr_neighbours;
12407                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
12408                                 if (_ptr_neighbours) {
12409                                         NDR_PULL_ALLOC(ndr, r->neighbours);
12410                                 } else {
12411                                         r->neighbours = NULL;
12412                                 }
12413                         break; }
12414
12415                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12416                                 uint32_t _ptr_cursors;
12417                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
12418                                 if (_ptr_cursors) {
12419                                         NDR_PULL_ALLOC(ndr, r->cursors);
12420                                 } else {
12421                                         r->cursors = NULL;
12422                                 }
12423                         break; }
12424
12425                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12426                                 uint32_t _ptr_objmetadata;
12427                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
12428                                 if (_ptr_objmetadata) {
12429                                         NDR_PULL_ALLOC(ndr, r->objmetadata);
12430                                 } else {
12431                                         r->objmetadata = NULL;
12432                                 }
12433                         break; }
12434
12435                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12436                                 uint32_t _ptr_connectfailures;
12437                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
12438                                 if (_ptr_connectfailures) {
12439                                         NDR_PULL_ALLOC(ndr, r->connectfailures);
12440                                 } else {
12441                                         r->connectfailures = NULL;
12442                                 }
12443                         break; }
12444
12445                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12446                                 uint32_t _ptr_linkfailures;
12447                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
12448                                 if (_ptr_linkfailures) {
12449                                         NDR_PULL_ALLOC(ndr, r->linkfailures);
12450                                 } else {
12451                                         r->linkfailures = NULL;
12452                                 }
12453                         break; }
12454
12455                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12456                                 uint32_t _ptr_pendingops;
12457                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
12458                                 if (_ptr_pendingops) {
12459                                         NDR_PULL_ALLOC(ndr, r->pendingops);
12460                                 } else {
12461                                         r->pendingops = NULL;
12462                                 }
12463                         break; }
12464
12465                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12466                                 uint32_t _ptr_attrvalmetadata;
12467                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
12468                                 if (_ptr_attrvalmetadata) {
12469                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
12470                                 } else {
12471                                         r->attrvalmetadata = NULL;
12472                                 }
12473                         break; }
12474
12475                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12476                                 uint32_t _ptr_cursors2;
12477                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
12478                                 if (_ptr_cursors2) {
12479                                         NDR_PULL_ALLOC(ndr, r->cursors2);
12480                                 } else {
12481                                         r->cursors2 = NULL;
12482                                 }
12483                         break; }
12484
12485                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12486                                 uint32_t _ptr_cursors3;
12487                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
12488                                 if (_ptr_cursors3) {
12489                                         NDR_PULL_ALLOC(ndr, r->cursors3);
12490                                 } else {
12491                                         r->cursors3 = NULL;
12492                                 }
12493                         break; }
12494
12495                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12496                                 uint32_t _ptr_objmetadata2;
12497                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
12498                                 if (_ptr_objmetadata2) {
12499                                         NDR_PULL_ALLOC(ndr, r->objmetadata2);
12500                                 } else {
12501                                         r->objmetadata2 = NULL;
12502                                 }
12503                         break; }
12504
12505                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12506                                 uint32_t _ptr_attrvalmetadata2;
12507                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
12508                                 if (_ptr_attrvalmetadata2) {
12509                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
12510                                 } else {
12511                                         r->attrvalmetadata2 = NULL;
12512                                 }
12513                         break; }
12514
12515                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
12516                                 uint32_t _ptr_neighbours02;
12517                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours02));
12518                                 if (_ptr_neighbours02) {
12519                                         NDR_PULL_ALLOC(ndr, r->neighbours02);
12520                                 } else {
12521                                         r->neighbours02 = NULL;
12522                                 }
12523                         break; }
12524
12525                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
12526                                 uint32_t _ptr_connections04;
12527                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connections04));
12528                                 if (_ptr_connections04) {
12529                                         NDR_PULL_ALLOC(ndr, r->connections04);
12530                                 } else {
12531                                         r->connections04 = NULL;
12532                                 }
12533                         break; }
12534
12535                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
12536                                 uint32_t _ptr_cursors05;
12537                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors05));
12538                                 if (_ptr_cursors05) {
12539                                         NDR_PULL_ALLOC(ndr, r->cursors05);
12540                                 } else {
12541                                         r->cursors05 = NULL;
12542                                 }
12543                         break; }
12544
12545                         case DRSUAPI_DS_REPLICA_INFO_06: {
12546                                 uint32_t _ptr_i06;
12547                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_i06));
12548                                 if (_ptr_i06) {
12549                                         NDR_PULL_ALLOC(ndr, r->i06);
12550                                 } else {
12551                                         r->i06 = NULL;
12552                                 }
12553                         break; }
12554
12555                         default:
12556                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12557                 }
12558         }
12559         if (ndr_flags & NDR_BUFFERS) {
12560                 switch (level) {
12561                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12562                                 if (r->neighbours) {
12563                                         _mem_save_neighbours_0 = NDR_PULL_GET_MEM_CTX(ndr);
12564                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours, 0);
12565                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12566                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours_0, 0);
12567                                 }
12568                         break;
12569
12570                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12571                                 if (r->cursors) {
12572                                         _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
12573                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
12574                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12575                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
12576                                 }
12577                         break;
12578
12579                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12580                                 if (r->objmetadata) {
12581                                         _mem_save_objmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12582                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata, 0);
12583                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12584                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata_0, 0);
12585                                 }
12586                         break;
12587
12588                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12589                                 if (r->connectfailures) {
12590                                         _mem_save_connectfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12591                                         NDR_PULL_SET_MEM_CTX(ndr, r->connectfailures, 0);
12592                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12593                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connectfailures_0, 0);
12594                                 }
12595                         break;
12596
12597                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12598                                 if (r->linkfailures) {
12599                                         _mem_save_linkfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12600                                         NDR_PULL_SET_MEM_CTX(ndr, r->linkfailures, 0);
12601                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12602                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linkfailures_0, 0);
12603                                 }
12604                         break;
12605
12606                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12607                                 if (r->pendingops) {
12608                                         _mem_save_pendingops_0 = NDR_PULL_GET_MEM_CTX(ndr);
12609                                         NDR_PULL_SET_MEM_CTX(ndr, r->pendingops, 0);
12610                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12611                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pendingops_0, 0);
12612                                 }
12613                         break;
12614
12615                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12616                                 if (r->attrvalmetadata) {
12617                                         _mem_save_attrvalmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12618                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata, 0);
12619                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12620                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata_0, 0);
12621                                 }
12622                         break;
12623
12624                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12625                                 if (r->cursors2) {
12626                                         _mem_save_cursors2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12627                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors2, 0);
12628                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12629                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors2_0, 0);
12630                                 }
12631                         break;
12632
12633                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12634                                 if (r->cursors3) {
12635                                         _mem_save_cursors3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12636                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors3, 0);
12637                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12638                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors3_0, 0);
12639                                 }
12640                         break;
12641
12642                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12643                                 if (r->objmetadata2) {
12644                                         _mem_save_objmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12645                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata2, 0);
12646                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12647                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata2_0, 0);
12648                                 }
12649                         break;
12650
12651                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12652                                 if (r->attrvalmetadata2) {
12653                                         _mem_save_attrvalmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12654                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata2, 0);
12655                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12656                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata2_0, 0);
12657                                 }
12658                         break;
12659
12660                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12661                                 if (r->neighbours02) {
12662                                         _mem_save_neighbours02_0 = NDR_PULL_GET_MEM_CTX(ndr);
12663                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours02, 0);
12664                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12665                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours02_0, 0);
12666                                 }
12667                         break;
12668
12669                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12670                                 if (r->connections04) {
12671                                         _mem_save_connections04_0 = NDR_PULL_GET_MEM_CTX(ndr);
12672                                         NDR_PULL_SET_MEM_CTX(ndr, r->connections04, 0);
12673                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12674                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connections04_0, 0);
12675                                 }
12676                         break;
12677
12678                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12679                                 if (r->cursors05) {
12680                                         _mem_save_cursors05_0 = NDR_PULL_GET_MEM_CTX(ndr);
12681                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors05, 0);
12682                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12683                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors05_0, 0);
12684                                 }
12685                         break;
12686
12687                         case DRSUAPI_DS_REPLICA_INFO_06:
12688                                 if (r->i06) {
12689                                         _mem_save_i06_0 = NDR_PULL_GET_MEM_CTX(ndr);
12690                                         NDR_PULL_SET_MEM_CTX(ndr, r->i06, 0);
12691                                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12692                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_i06_0, 0);
12693                                 }
12694                         break;
12695
12696                         default:
12697                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12698                 }
12699         }
12700         return NDR_ERR_SUCCESS;
12701 }
12702
12703 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaInfo *r)
12704 {
12705         int level;
12706         level = ndr_print_get_switch_value(ndr, r);
12707         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaInfo");
12708         switch (level) {
12709                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12710                         ndr_print_ptr(ndr, "neighbours", r->neighbours);
12711                         ndr->depth++;
12712                         if (r->neighbours) {
12713                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours", r->neighbours);
12714                         }
12715                         ndr->depth--;
12716                 break;
12717
12718                 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12719                         ndr_print_ptr(ndr, "cursors", r->cursors);
12720                         ndr->depth++;
12721                         if (r->cursors) {
12722                                 ndr_print_drsuapi_DsReplicaCursorCtr(ndr, "cursors", r->cursors);
12723                         }
12724                         ndr->depth--;
12725                 break;
12726
12727                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12728                         ndr_print_ptr(ndr, "objmetadata", r->objmetadata);
12729                         ndr->depth++;
12730                         if (r->objmetadata) {
12731                                 ndr_print_drsuapi_DsReplicaObjMetaDataCtr(ndr, "objmetadata", r->objmetadata);
12732                         }
12733                         ndr->depth--;
12734                 break;
12735
12736                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12737                         ndr_print_ptr(ndr, "connectfailures", r->connectfailures);
12738                         ndr->depth++;
12739                         if (r->connectfailures) {
12740                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "connectfailures", r->connectfailures);
12741                         }
12742                         ndr->depth--;
12743                 break;
12744
12745                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12746                         ndr_print_ptr(ndr, "linkfailures", r->linkfailures);
12747                         ndr->depth++;
12748                         if (r->linkfailures) {
12749                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "linkfailures", r->linkfailures);
12750                         }
12751                         ndr->depth--;
12752                 break;
12753
12754                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12755                         ndr_print_ptr(ndr, "pendingops", r->pendingops);
12756                         ndr->depth++;
12757                         if (r->pendingops) {
12758                                 ndr_print_drsuapi_DsReplicaOpCtr(ndr, "pendingops", r->pendingops);
12759                         }
12760                         ndr->depth--;
12761                 break;
12762
12763                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12764                         ndr_print_ptr(ndr, "attrvalmetadata", r->attrvalmetadata);
12765                         ndr->depth++;
12766                         if (r->attrvalmetadata) {
12767                                 ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, "attrvalmetadata", r->attrvalmetadata);
12768                         }
12769                         ndr->depth--;
12770                 break;
12771
12772                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12773                         ndr_print_ptr(ndr, "cursors2", r->cursors2);
12774                         ndr->depth++;
12775                         if (r->cursors2) {
12776                                 ndr_print_drsuapi_DsReplicaCursor2Ctr(ndr, "cursors2", r->cursors2);
12777                         }
12778                         ndr->depth--;
12779                 break;
12780
12781                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12782                         ndr_print_ptr(ndr, "cursors3", r->cursors3);
12783                         ndr->depth++;
12784                         if (r->cursors3) {
12785                                 ndr_print_drsuapi_DsReplicaCursor3Ctr(ndr, "cursors3", r->cursors3);
12786                         }
12787                         ndr->depth--;
12788                 break;
12789
12790                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12791                         ndr_print_ptr(ndr, "objmetadata2", r->objmetadata2);
12792                         ndr->depth++;
12793                         if (r->objmetadata2) {
12794                                 ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(ndr, "objmetadata2", r->objmetadata2);
12795                         }
12796                         ndr->depth--;
12797                 break;
12798
12799                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12800                         ndr_print_ptr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12801                         ndr->depth++;
12802                         if (r->attrvalmetadata2) {
12803                                 ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12804                         }
12805                         ndr->depth--;
12806                 break;
12807
12808                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12809                         ndr_print_ptr(ndr, "neighbours02", r->neighbours02);
12810                         ndr->depth++;
12811                         if (r->neighbours02) {
12812                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours02", r->neighbours02);
12813                         }
12814                         ndr->depth--;
12815                 break;
12816
12817                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12818                         ndr_print_ptr(ndr, "connections04", r->connections04);
12819                         ndr->depth++;
12820                         if (r->connections04) {
12821                                 ndr_print_drsuapi_DsReplicaConnection04Ctr(ndr, "connections04", r->connections04);
12822                         }
12823                         ndr->depth--;
12824                 break;
12825
12826                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12827                         ndr_print_ptr(ndr, "cursors05", r->cursors05);
12828                         ndr->depth++;
12829                         if (r->cursors05) {
12830                                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "cursors05", r->cursors05);
12831                         }
12832                         ndr->depth--;
12833                 break;
12834
12835                 case DRSUAPI_DS_REPLICA_INFO_06:
12836                         ndr_print_ptr(ndr, "i06", r->i06);
12837                         ndr->depth++;
12838                         if (r->i06) {
12839                                 ndr_print_drsuapi_DsReplica06Ctr(ndr, "i06", r->i06);
12840                         }
12841                         ndr->depth--;
12842                 break;
12843
12844                 default:
12845                         ndr_print_bad_level(ndr, name, level);
12846         }
12847 }
12848
12849 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Ctr *r)
12850 {
12851         if (ndr_flags & NDR_SCALARS) {
12852                 int level = ndr_push_get_switch_value(ndr, r);
12853                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12854                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12855                 switch (level) {
12856                         case 1: {
12857                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12858                         break; }
12859
12860                         default:
12861                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12862                 }
12863         }
12864         if (ndr_flags & NDR_BUFFERS) {
12865                 int level = ndr_push_get_switch_value(ndr, r);
12866                 switch (level) {
12867                         case 1:
12868                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12869                         break;
12870
12871                         default:
12872                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12873                 }
12874         }
12875         return NDR_ERR_SUCCESS;
12876 }
12877
12878 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Ctr *r)
12879 {
12880         int level;
12881         int32_t _level;
12882         level = ndr_pull_get_switch_value(ndr, r);
12883         if (ndr_flags & NDR_SCALARS) {
12884                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12885                 if (_level != level) {
12886                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12887                 }
12888                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12889                 switch (level) {
12890                         case 1: {
12891                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12892                         break; }
12893
12894                         default:
12895                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12896                 }
12897         }
12898         if (ndr_flags & NDR_BUFFERS) {
12899                 switch (level) {
12900                         case 1:
12901                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12902                         break;
12903
12904                         default:
12905                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12906                 }
12907         }
12908         return NDR_ERR_SUCCESS;
12909 }
12910
12911 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Ctr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Ctr *r)
12912 {
12913         int level;
12914         level = ndr_print_get_switch_value(ndr, r);
12915         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Ctr");
12916         switch (level) {
12917                 case 1:
12918                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
12919                 break;
12920
12921                 default:
12922                         ndr_print_bad_level(ndr, name, level);
12923         }
12924 }
12925
12926 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMemberships2Request1 *r)
12927 {
12928         uint32_t cntr_req_array_1;
12929         if (ndr_flags & NDR_SCALARS) {
12930                 NDR_CHECK(ndr_push_align(ndr, 5));
12931                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12932                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
12933                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12934         }
12935         if (ndr_flags & NDR_BUFFERS) {
12936                 if (r->req_array) {
12937                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
12938                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12939                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
12940                         }
12941                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12942                                 if (r->req_array[cntr_req_array_1]) {
12943                                         NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12944                                 }
12945                         }
12946                 }
12947         }
12948         return NDR_ERR_SUCCESS;
12949 }
12950
12951 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
12952 {
12953         uint32_t _ptr_req_array;
12954         uint32_t cntr_req_array_1;
12955         TALLOC_CTX *_mem_save_req_array_0;
12956         TALLOC_CTX *_mem_save_req_array_1;
12957         TALLOC_CTX *_mem_save_req_array_2;
12958         if (ndr_flags & NDR_SCALARS) {
12959                 NDR_CHECK(ndr_pull_align(ndr, 5));
12960                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12961                 if (r->num_req < 1 || r->num_req > 10000) {
12962                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12963                 }
12964                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12965                 if (_ptr_req_array) {
12966                         NDR_PULL_ALLOC(ndr, r->req_array);
12967                 } else {
12968                         r->req_array = NULL;
12969                 }
12970                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12971         }
12972         if (ndr_flags & NDR_BUFFERS) {
12973                 if (r->req_array) {
12974                         _mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12975                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12976                         NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
12977                         NDR_PULL_ALLOC_N(ndr, r->req_array, ndr_get_array_size(ndr, &r->req_array));
12978                         _mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12979                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12980                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12981                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12982                                 if (_ptr_req_array) {
12983                                         NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
12984                                 } else {
12985                                         r->req_array[cntr_req_array_1] = NULL;
12986                                 }
12987                         }
12988                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12989                                 if (r->req_array[cntr_req_array_1]) {
12990                                         _mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
12991                                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
12992                                         NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12993                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_2, 0);
12994                                 }
12995                         }
12996                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_1, 0);
12997                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_0, 0);
12998                 }
12999                 if (r->req_array) {
13000                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->req_array, r->num_req));
13001                 }
13002         }
13003         return NDR_ERR_SUCCESS;
13004 }
13005
13006 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMemberships2Request1 *r)
13007 {
13008         uint32_t cntr_req_array_1;
13009         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2Request1");
13010         ndr->depth++;
13011         ndr_print_uint32(ndr, "num_req", r->num_req);
13012         ndr_print_ptr(ndr, "req_array", r->req_array);
13013         ndr->depth++;
13014         if (r->req_array) {
13015                 ndr->print(ndr, "%s: ARRAY(%d)", "req_array", (int)r->num_req);
13016                 ndr->depth++;
13017                 for (cntr_req_array_1=0;cntr_req_array_1<r->num_req;cntr_req_array_1++) {
13018                         char *idx_1=NULL;
13019                         if (asprintf(&idx_1, "[%d]", cntr_req_array_1) != -1) {
13020                                 ndr_print_ptr(ndr, "req_array", r->req_array[cntr_req_array_1]);
13021                                 ndr->depth++;
13022                                 if (r->req_array[cntr_req_array_1]) {
13023                                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req_array", r->req_array[cntr_req_array_1]);
13024                                 }
13025                                 ndr->depth--;
13026                                 free(idx_1);
13027                         }
13028                 }
13029                 ndr->depth--;
13030         }
13031         ndr->depth--;
13032         ndr->depth--;
13033 }
13034
13035 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Request *r)
13036 {
13037         if (ndr_flags & NDR_SCALARS) {
13038                 int level = ndr_push_get_switch_value(ndr, r);
13039                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13040                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13041                 switch (level) {
13042                         case 1: {
13043                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
13044                         break; }
13045
13046                         default:
13047                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13048                 }
13049         }
13050         if (ndr_flags & NDR_BUFFERS) {
13051                 int level = ndr_push_get_switch_value(ndr, r);
13052                 switch (level) {
13053                         case 1:
13054                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
13055                         break;
13056
13057                         default:
13058                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13059                 }
13060         }
13061         return NDR_ERR_SUCCESS;
13062 }
13063
13064 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Request *r)
13065 {
13066         int level;
13067         int32_t _level;
13068         level = ndr_pull_get_switch_value(ndr, r);
13069         if (ndr_flags & NDR_SCALARS) {
13070                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13071                 if (_level != level) {
13072                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13073                 }
13074                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13075                 switch (level) {
13076                         case 1: {
13077                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
13078                         break; }
13079
13080                         default:
13081                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13082                 }
13083         }
13084         if (ndr_flags & NDR_BUFFERS) {
13085                 switch (level) {
13086                         case 1:
13087                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
13088                         break;
13089
13090                         default:
13091                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13092                 }
13093         }
13094         return NDR_ERR_SUCCESS;
13095 }
13096
13097 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Request *r)
13098 {
13099         int level;
13100         level = ndr_print_get_switch_value(ndr, r);
13101         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Request");
13102         switch (level) {
13103                 case 1:
13104                         ndr_print_drsuapi_DsGetMemberships2Request1(ndr, "req1", &r->req1);
13105                 break;
13106
13107                 default:
13108                         ndr_print_bad_level(ndr, name, level);
13109         }
13110 }
13111
13112 static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsSiteCostInfo *r)
13113 {
13114         if (ndr_flags & NDR_SCALARS) {
13115                 NDR_CHECK(ndr_push_align(ndr, 4));
13116                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
13117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
13118                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
13119         }
13120         if (ndr_flags & NDR_BUFFERS) {
13121         }
13122         return NDR_ERR_SUCCESS;
13123 }
13124
13125 static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsSiteCostInfo *r)
13126 {
13127         if (ndr_flags & NDR_SCALARS) {
13128                 NDR_CHECK(ndr_pull_align(ndr, 4));
13129                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
13130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
13131                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
13132         }
13133         if (ndr_flags & NDR_BUFFERS) {
13134         }
13135         return NDR_ERR_SUCCESS;
13136 }
13137
13138 _PUBLIC_ void ndr_print_drsuapi_DsSiteCostInfo(struct ndr_print *ndr, const char *name, const struct drsuapi_DsSiteCostInfo *r)
13139 {
13140         ndr_print_struct(ndr, name, "drsuapi_DsSiteCostInfo");
13141         ndr->depth++;
13142         ndr_print_WERROR(ndr, "error_code", r->error_code);
13143         ndr_print_uint32(ndr, "site_cost", r->site_cost);
13144         ndr->depth--;
13145 }
13146
13147 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostCtr1 *r)
13148 {
13149         uint32_t cntr_info_1;
13150         if (ndr_flags & NDR_SCALARS) {
13151                 NDR_CHECK(ndr_push_align(ndr, 5));
13152                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
13153                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
13154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
13155                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13156         }
13157         if (ndr_flags & NDR_BUFFERS) {
13158                 if (r->info) {
13159                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_info));
13160                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
13161                                 NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
13162                         }
13163                 }
13164         }
13165         return NDR_ERR_SUCCESS;
13166 }
13167
13168 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
13169 {
13170         uint32_t _ptr_info;
13171         uint32_t cntr_info_1;
13172         TALLOC_CTX *_mem_save_info_0;
13173         TALLOC_CTX *_mem_save_info_1;
13174         if (ndr_flags & NDR_SCALARS) {
13175                 NDR_CHECK(ndr_pull_align(ndr, 5));
13176                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
13177                 if (r->num_info > 10000) {
13178                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
13179                 }
13180                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
13181                 if (_ptr_info) {
13182                         NDR_PULL_ALLOC(ndr, r->info);
13183                 } else {
13184                         r->info = NULL;
13185                 }
13186                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
13187                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13188         }
13189         if (ndr_flags & NDR_BUFFERS) {
13190                 if (r->info) {
13191                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13192                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
13193                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
13194                         NDR_PULL_ALLOC_N(ndr, r->info, ndr_get_array_size(ndr, &r->info));
13195                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
13196                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
13197                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
13198                                 NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
13199                         }
13200                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
13201                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
13202                 }
13203                 if (r->info) {
13204                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info, r->num_info));
13205                 }
13206         }
13207         return NDR_ERR_SUCCESS;
13208 }
13209
13210 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostCtr1 *r)
13211 {
13212         uint32_t cntr_info_1;
13213         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostCtr1");
13214         ndr->depth++;
13215         ndr_print_uint32(ndr, "num_info", r->num_info);
13216         ndr_print_ptr(ndr, "info", r->info);
13217         ndr->depth++;
13218         if (r->info) {
13219                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->num_info);
13220                 ndr->depth++;
13221                 for (cntr_info_1=0;cntr_info_1<r->num_info;cntr_info_1++) {
13222                         char *idx_1=NULL;
13223                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
13224                                 ndr_print_drsuapi_DsSiteCostInfo(ndr, "info", &r->info[cntr_info_1]);
13225                                 free(idx_1);
13226                         }
13227                 }
13228                 ndr->depth--;
13229         }
13230         ndr->depth--;
13231         ndr_print_uint32(ndr, "unknown", r->unknown);
13232         ndr->depth--;
13233 }
13234
13235 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostCtr *r)
13236 {
13237         if (ndr_flags & NDR_SCALARS) {
13238                 int level = ndr_push_get_switch_value(ndr, r);
13239                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13240                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13241                 switch (level) {
13242                         case 1: {
13243                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
13244                         break; }
13245
13246                         default:
13247                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13248                 }
13249         }
13250         if (ndr_flags & NDR_BUFFERS) {
13251                 int level = ndr_push_get_switch_value(ndr, r);
13252                 switch (level) {
13253                         case 1:
13254                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
13255                         break;
13256
13257                         default:
13258                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13259                 }
13260         }
13261         return NDR_ERR_SUCCESS;
13262 }
13263
13264 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostCtr *r)
13265 {
13266         int level;
13267         int32_t _level;
13268         level = ndr_pull_get_switch_value(ndr, r);
13269         if (ndr_flags & NDR_SCALARS) {
13270                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13271                 if (_level != level) {
13272                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13273                 }
13274                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13275                 switch (level) {
13276                         case 1: {
13277                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
13278                         break; }
13279
13280                         default:
13281                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13282                 }
13283         }
13284         if (ndr_flags & NDR_BUFFERS) {
13285                 switch (level) {
13286                         case 1:
13287                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
13288                         break;
13289
13290                         default:
13291                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13292                 }
13293         }
13294         return NDR_ERR_SUCCESS;
13295 }
13296
13297 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostCtr *r)
13298 {
13299         int level;
13300         level = ndr_print_get_switch_value(ndr, r);
13301         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostCtr");
13302         switch (level) {
13303                 case 1:
13304                         ndr_print_drsuapi_QuerySitesByCostCtr1(ndr, "ctr1", &r->ctr1);
13305                 break;
13306
13307                 default:
13308                         ndr_print_bad_level(ndr, name, level);
13309         }
13310 }
13311
13312 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostRequest1 *r)
13313 {
13314         uint32_t cntr_site_to_1;
13315         if (ndr_flags & NDR_SCALARS) {
13316                 NDR_CHECK(ndr_push_align(ndr, 5));
13317                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
13318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
13319                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
13320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13321                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13322         }
13323         if (ndr_flags & NDR_BUFFERS) {
13324                 if (r->site_from) {
13325                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13326                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13327                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13328                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13329                 }
13330                 if (r->site_to) {
13331                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
13332                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13333                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
13334                         }
13335                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13336                                 if (r->site_to[cntr_site_to_1]) {
13337                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13338                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
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_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));
13341                                 }
13342                         }
13343                 }
13344         }
13345         return NDR_ERR_SUCCESS;
13346 }
13347
13348 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
13349 {
13350         uint32_t _ptr_site_from;
13351         TALLOC_CTX *_mem_save_site_from_0;
13352         uint32_t _ptr_site_to;
13353         uint32_t cntr_site_to_1;
13354         TALLOC_CTX *_mem_save_site_to_0;
13355         TALLOC_CTX *_mem_save_site_to_1;
13356         TALLOC_CTX *_mem_save_site_to_2;
13357         if (ndr_flags & NDR_SCALARS) {
13358                 NDR_CHECK(ndr_pull_align(ndr, 5));
13359                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
13360                 if (_ptr_site_from) {
13361                         NDR_PULL_ALLOC(ndr, r->site_from);
13362                 } else {
13363                         r->site_from = NULL;
13364                 }
13365                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
13366                 if (r->num_req < 1 || r->num_req > 10000) {
13367                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
13368                 }
13369                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13370                 if (_ptr_site_to) {
13371                         NDR_PULL_ALLOC(ndr, r->site_to);
13372                 } else {
13373                         r->site_to = NULL;
13374                 }
13375                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13376                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13377         }
13378         if (ndr_flags & NDR_BUFFERS) {
13379                 if (r->site_from) {
13380                         _mem_save_site_from_0 = NDR_PULL_GET_MEM_CTX(ndr);
13381                         NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
13382                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
13383                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
13384                         if (ndr_get_array_length(ndr, &r->site_from) > ndr_get_array_size(ndr, &r->site_from)) {
13385                                 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));
13386                         }
13387                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t)));
13388                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t), CH_UTF16));
13389                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
13390                 }
13391                 if (r->site_to) {
13392                         _mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
13393                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13394                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
13395                         NDR_PULL_ALLOC_N(ndr, r->site_to, ndr_get_array_size(ndr, &r->site_to));
13396                         _mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
13397                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13398                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13399                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13400                                 if (_ptr_site_to) {
13401                                         NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
13402                                 } else {
13403                                         r->site_to[cntr_site_to_1] = NULL;
13404                                 }
13405                         }
13406                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13407                                 if (r->site_to[cntr_site_to_1]) {
13408                                         _mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
13409                                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
13410                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
13411                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
13412                                         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])) {
13413                                                 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]));
13414                                         }
13415                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t)));
13416                                         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));
13417                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
13418                                 }
13419                         }
13420                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_1, 0);
13421                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_0, 0);
13422                 }
13423                 if (r->site_to) {
13424                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->site_to, r->num_req));
13425                 }
13426         }
13427         return NDR_ERR_SUCCESS;
13428 }
13429
13430 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostRequest1 *r)
13431 {
13432         uint32_t cntr_site_to_1;
13433         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostRequest1");
13434         ndr->depth++;
13435         ndr_print_ptr(ndr, "site_from", r->site_from);
13436         ndr->depth++;
13437         if (r->site_from) {
13438                 ndr_print_string(ndr, "site_from", r->site_from);
13439         }
13440         ndr->depth--;
13441         ndr_print_uint32(ndr, "num_req", r->num_req);
13442         ndr_print_ptr(ndr, "site_to", r->site_to);
13443         ndr->depth++;
13444         if (r->site_to) {
13445                 ndr->print(ndr, "%s: ARRAY(%d)", "site_to", (int)r->num_req);
13446                 ndr->depth++;
13447                 for (cntr_site_to_1=0;cntr_site_to_1<r->num_req;cntr_site_to_1++) {
13448                         char *idx_1=NULL;
13449                         if (asprintf(&idx_1, "[%d]", cntr_site_to_1) != -1) {
13450                                 ndr_print_ptr(ndr, "site_to", r->site_to[cntr_site_to_1]);
13451                                 ndr->depth++;
13452                                 if (r->site_to[cntr_site_to_1]) {
13453                                         ndr_print_string(ndr, "site_to", r->site_to[cntr_site_to_1]);
13454                                 }
13455                                 ndr->depth--;
13456                                 free(idx_1);
13457                         }
13458                 }
13459                 ndr->depth--;
13460         }
13461         ndr->depth--;
13462         ndr_print_uint32(ndr, "flags", r->flags);
13463         ndr->depth--;
13464 }
13465
13466 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostRequest *r)
13467 {
13468         if (ndr_flags & NDR_SCALARS) {
13469                 int level = ndr_push_get_switch_value(ndr, r);
13470                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13471                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13472                 switch (level) {
13473                         case 1: {
13474                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13475                         break; }
13476
13477                         default:
13478                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13479                 }
13480         }
13481         if (ndr_flags & NDR_BUFFERS) {
13482                 int level = ndr_push_get_switch_value(ndr, r);
13483                 switch (level) {
13484                         case 1:
13485                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13486                         break;
13487
13488                         default:
13489                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13490                 }
13491         }
13492         return NDR_ERR_SUCCESS;
13493 }
13494
13495 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostRequest *r)
13496 {
13497         int level;
13498         int32_t _level;
13499         level = ndr_pull_get_switch_value(ndr, r);
13500         if (ndr_flags & NDR_SCALARS) {
13501                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13502                 if (_level != level) {
13503                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13504                 }
13505                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13506                 switch (level) {
13507                         case 1: {
13508                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13509                         break; }
13510
13511                         default:
13512                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13513                 }
13514         }
13515         if (ndr_flags & NDR_BUFFERS) {
13516                 switch (level) {
13517                         case 1:
13518                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13519                         break;
13520
13521                         default:
13522                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13523                 }
13524         }
13525         return NDR_ERR_SUCCESS;
13526 }
13527
13528 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostRequest *r)
13529 {
13530         int level;
13531         level = ndr_print_get_switch_value(ndr, r);
13532         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostRequest");
13533         switch (level) {
13534                 case 1:
13535                         ndr_print_drsuapi_QuerySitesByCostRequest1(ndr, "req1", &r->req1);
13536                 break;
13537
13538                 default:
13539                         ndr_print_bad_level(ndr, name, level);
13540         }
13541 }
13542
13543 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsBind(struct ndr_push *ndr, int flags, const struct drsuapi_DsBind *r)
13544 {
13545         if (flags & NDR_IN) {
13546                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_guid));
13547                 if (r->in.bind_guid) {
13548                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13549                 }
13550                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_info));
13551                 if (r->in.bind_info) {
13552                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13553                 }
13554         }
13555         if (flags & NDR_OUT) {
13556                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.bind_info));
13557                 if (r->out.bind_info) {
13558                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13559                 }
13560                 if (r->out.bind_handle == NULL) {
13561                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13562                 }
13563                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13564                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13565         }
13566         return NDR_ERR_SUCCESS;
13567 }
13568
13569 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsBind(struct ndr_pull *ndr, int flags, struct drsuapi_DsBind *r)
13570 {
13571         uint32_t _ptr_bind_guid;
13572         uint32_t _ptr_bind_info;
13573         TALLOC_CTX *_mem_save_bind_guid_0;
13574         TALLOC_CTX *_mem_save_bind_info_0;
13575         TALLOC_CTX *_mem_save_bind_handle_0;
13576         if (flags & NDR_IN) {
13577                 ZERO_STRUCT(r->out);
13578
13579                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_guid));
13580                 if (_ptr_bind_guid) {
13581                         NDR_PULL_ALLOC(ndr, r->in.bind_guid);
13582                 } else {
13583                         r->in.bind_guid = NULL;
13584                 }
13585                 if (r->in.bind_guid) {
13586                         _mem_save_bind_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
13587                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_guid, 0);
13588                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13589                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_guid_0, 0);
13590                 }
13591                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13592                 if (_ptr_bind_info) {
13593                         NDR_PULL_ALLOC(ndr, r->in.bind_info);
13594                 } else {
13595                         r->in.bind_info = NULL;
13596                 }
13597                 if (r->in.bind_info) {
13598                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13599                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_info, 0);
13600                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13601                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13602                 }
13603                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13604                 ZERO_STRUCTP(r->out.bind_handle);
13605         }
13606         if (flags & NDR_OUT) {
13607                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13608                 if (_ptr_bind_info) {
13609                         NDR_PULL_ALLOC(ndr, r->out.bind_info);
13610                 } else {
13611                         r->out.bind_info = NULL;
13612                 }
13613                 if (r->out.bind_info) {
13614                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13615                         NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_info, 0);
13616                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13617                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13618                 }
13619                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13620                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13621                 }
13622                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13623                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13624                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13625                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13626                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13627         }
13628         return NDR_ERR_SUCCESS;
13629 }
13630
13631 _PUBLIC_ void ndr_print_drsuapi_DsBind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsBind *r)
13632 {
13633         ndr_print_struct(ndr, name, "drsuapi_DsBind");
13634         ndr->depth++;
13635         if (flags & NDR_SET_VALUES) {
13636                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13637         }
13638         if (flags & NDR_IN) {
13639                 ndr_print_struct(ndr, "in", "drsuapi_DsBind");
13640                 ndr->depth++;
13641                 ndr_print_ptr(ndr, "bind_guid", r->in.bind_guid);
13642                 ndr->depth++;
13643                 if (r->in.bind_guid) {
13644                         ndr_print_GUID(ndr, "bind_guid", r->in.bind_guid);
13645                 }
13646                 ndr->depth--;
13647                 ndr_print_ptr(ndr, "bind_info", r->in.bind_info);
13648                 ndr->depth++;
13649                 if (r->in.bind_info) {
13650                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->in.bind_info);
13651                 }
13652                 ndr->depth--;
13653                 ndr->depth--;
13654         }
13655         if (flags & NDR_OUT) {
13656                 ndr_print_struct(ndr, "out", "drsuapi_DsBind");
13657                 ndr->depth++;
13658                 ndr_print_ptr(ndr, "bind_info", r->out.bind_info);
13659                 ndr->depth++;
13660                 if (r->out.bind_info) {
13661                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->out.bind_info);
13662                 }
13663                 ndr->depth--;
13664                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13665                 ndr->depth++;
13666                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13667                 ndr->depth--;
13668                 ndr_print_WERROR(ndr, "result", r->out.result);
13669                 ndr->depth--;
13670         }
13671         ndr->depth--;
13672 }
13673
13674 static enum ndr_err_code ndr_push_drsuapi_DsUnbind(struct ndr_push *ndr, int flags, const struct drsuapi_DsUnbind *r)
13675 {
13676         if (flags & NDR_IN) {
13677                 if (r->in.bind_handle == NULL) {
13678                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13679                 }
13680                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13681         }
13682         if (flags & NDR_OUT) {
13683                 if (r->out.bind_handle == NULL) {
13684                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13685                 }
13686                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13687                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13688         }
13689         return NDR_ERR_SUCCESS;
13690 }
13691
13692 static enum ndr_err_code ndr_pull_drsuapi_DsUnbind(struct ndr_pull *ndr, int flags, struct drsuapi_DsUnbind *r)
13693 {
13694         TALLOC_CTX *_mem_save_bind_handle_0;
13695         if (flags & NDR_IN) {
13696                 ZERO_STRUCT(r->out);
13697
13698                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13699                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13700                 }
13701                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13702                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13703                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13704                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13705                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13706                 *r->out.bind_handle = *r->in.bind_handle;
13707         }
13708         if (flags & NDR_OUT) {
13709                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13710                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13711                 }
13712                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13713                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13714                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13715                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13716                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13717         }
13718         return NDR_ERR_SUCCESS;
13719 }
13720
13721 _PUBLIC_ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsUnbind *r)
13722 {
13723         ndr_print_struct(ndr, name, "drsuapi_DsUnbind");
13724         ndr->depth++;
13725         if (flags & NDR_SET_VALUES) {
13726                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13727         }
13728         if (flags & NDR_IN) {
13729                 ndr_print_struct(ndr, "in", "drsuapi_DsUnbind");
13730                 ndr->depth++;
13731                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13732                 ndr->depth++;
13733                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13734                 ndr->depth--;
13735                 ndr->depth--;
13736         }
13737         if (flags & NDR_OUT) {
13738                 ndr_print_struct(ndr, "out", "drsuapi_DsUnbind");
13739                 ndr->depth++;
13740                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13741                 ndr->depth++;
13742                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13743                 ndr->depth--;
13744                 ndr_print_WERROR(ndr, "result", r->out.result);
13745                 ndr->depth--;
13746         }
13747         ndr->depth--;
13748 }
13749
13750 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSync(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaSync *r)
13751 {
13752         if (flags & NDR_IN) {
13753                 if (r->in.bind_handle == NULL) {
13754                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13755                 }
13756                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13757                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13758                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13759                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13760         }
13761         if (flags & NDR_OUT) {
13762                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13763         }
13764         return NDR_ERR_SUCCESS;
13765 }
13766
13767 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSync(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaSync *r)
13768 {
13769         TALLOC_CTX *_mem_save_bind_handle_0;
13770         if (flags & NDR_IN) {
13771                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13772                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13773                 }
13774                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13775                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13776                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13777                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13778                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13779                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13780                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13781         }
13782         if (flags & NDR_OUT) {
13783                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13784         }
13785         return NDR_ERR_SUCCESS;
13786 }
13787
13788 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r)
13789 {
13790         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSync");
13791         ndr->depth++;
13792         if (flags & NDR_SET_VALUES) {
13793                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13794         }
13795         if (flags & NDR_IN) {
13796                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaSync");
13797                 ndr->depth++;
13798                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13799                 ndr->depth++;
13800                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13801                 ndr->depth--;
13802                 ndr_print_int32(ndr, "level", r->in.level);
13803                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13804                 ndr_print_drsuapi_DsReplicaSyncRequest(ndr, "req", &r->in.req);
13805                 ndr->depth--;
13806         }
13807         if (flags & NDR_OUT) {
13808                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaSync");
13809                 ndr->depth++;
13810                 ndr_print_WERROR(ndr, "result", r->out.result);
13811                 ndr->depth--;
13812         }
13813         ndr->depth--;
13814 }
13815
13816 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChanges(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNCChanges *r)
13817 {
13818         if (flags & NDR_IN) {
13819                 if (r->in.bind_handle == NULL) {
13820                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13821                 }
13822                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13823                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13824                 if (r->in.req == NULL) {
13825                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13826                 }
13827                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13828                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13829         }
13830         if (flags & NDR_OUT) {
13831                 if (r->out.level_out == NULL) {
13832                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13833                 }
13834                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13835                 if (r->out.ctr == NULL) {
13836                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13837                 }
13838                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13839                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13840                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13841         }
13842         return NDR_ERR_SUCCESS;
13843 }
13844
13845 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChanges(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNCChanges *r)
13846 {
13847         TALLOC_CTX *_mem_save_bind_handle_0;
13848         TALLOC_CTX *_mem_save_req_0;
13849         TALLOC_CTX *_mem_save_level_out_0;
13850         TALLOC_CTX *_mem_save_ctr_0;
13851         if (flags & NDR_IN) {
13852                 ZERO_STRUCT(r->out);
13853
13854                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13855                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13856                 }
13857                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13858                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13859                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13860                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13861                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13862                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13863                         NDR_PULL_ALLOC(ndr, r->in.req);
13864                 }
13865                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13866                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13867                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13868                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13869                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13870                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13871                 ZERO_STRUCTP(r->out.level_out);
13872                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13873                 ZERO_STRUCTP(r->out.ctr);
13874         }
13875         if (flags & NDR_OUT) {
13876                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13877                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13878                 }
13879                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13880                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13881                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13882                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13883                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13884                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13885                 }
13886                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13887                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13888                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13889                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13890                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13891                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13892         }
13893         return NDR_ERR_SUCCESS;
13894 }
13895
13896 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r)
13897 {
13898         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChanges");
13899         ndr->depth++;
13900         if (flags & NDR_SET_VALUES) {
13901                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13902         }
13903         if (flags & NDR_IN) {
13904                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNCChanges");
13905                 ndr->depth++;
13906                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13907                 ndr->depth++;
13908                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13909                 ndr->depth--;
13910                 ndr_print_int32(ndr, "level", r->in.level);
13911                 ndr_print_ptr(ndr, "req", r->in.req);
13912                 ndr->depth++;
13913                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13914                 ndr_print_drsuapi_DsGetNCChangesRequest(ndr, "req", r->in.req);
13915                 ndr->depth--;
13916                 ndr->depth--;
13917         }
13918         if (flags & NDR_OUT) {
13919                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNCChanges");
13920                 ndr->depth++;
13921                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13922                 ndr->depth++;
13923                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13924                 ndr->depth--;
13925                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13926                 ndr->depth++;
13927                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13928                 ndr_print_drsuapi_DsGetNCChangesCtr(ndr, "ctr", r->out.ctr);
13929                 ndr->depth--;
13930                 ndr_print_WERROR(ndr, "result", r->out.result);
13931                 ndr->depth--;
13932         }
13933         ndr->depth--;
13934 }
13935
13936 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefs(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13937 {
13938         if (flags & NDR_IN) {
13939                 if (r->in.bind_handle == NULL) {
13940                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13941                 }
13942                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13943                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13944                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13945                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13946         }
13947         if (flags & NDR_OUT) {
13948                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13949         }
13950         return NDR_ERR_SUCCESS;
13951 }
13952
13953 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefs(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaUpdateRefs *r)
13954 {
13955         TALLOC_CTX *_mem_save_bind_handle_0;
13956         if (flags & NDR_IN) {
13957                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13958                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13959                 }
13960                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13961                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13962                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13963                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13964                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13965                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13966                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13967         }
13968         if (flags & NDR_OUT) {
13969                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13970         }
13971         return NDR_ERR_SUCCESS;
13972 }
13973
13974 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13975 {
13976         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefs");
13977         ndr->depth++;
13978         if (flags & NDR_SET_VALUES) {
13979                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13980         }
13981         if (flags & NDR_IN) {
13982                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaUpdateRefs");
13983                 ndr->depth++;
13984                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13985                 ndr->depth++;
13986                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13987                 ndr->depth--;
13988                 ndr_print_int32(ndr, "level", r->in.level);
13989                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13990                 ndr_print_drsuapi_DsReplicaUpdateRefsRequest(ndr, "req", &r->in.req);
13991                 ndr->depth--;
13992         }
13993         if (flags & NDR_OUT) {
13994                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaUpdateRefs");
13995                 ndr->depth++;
13996                 ndr_print_WERROR(ndr, "result", r->out.result);
13997                 ndr->depth--;
13998         }
13999         ndr->depth--;
14000 }
14001
14002 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAdd(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaAdd *r)
14003 {
14004         if (flags & NDR_IN) {
14005                 if (r->in.bind_handle == NULL) {
14006                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14007                 }
14008                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14009                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14010                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
14011                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14012         }
14013         if (flags & NDR_OUT) {
14014                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14015         }
14016         return NDR_ERR_SUCCESS;
14017 }
14018
14019 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAdd(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaAdd *r)
14020 {
14021         TALLOC_CTX *_mem_save_bind_handle_0;
14022         if (flags & NDR_IN) {
14023                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14024                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14025                 }
14026                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14027                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14028                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14029                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14030                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14031                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
14032                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14033         }
14034         if (flags & NDR_OUT) {
14035                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14036         }
14037         return NDR_ERR_SUCCESS;
14038 }
14039
14040 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r)
14041 {
14042         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAdd");
14043         ndr->depth++;
14044         if (flags & NDR_SET_VALUES) {
14045                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14046         }
14047         if (flags & NDR_IN) {
14048                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaAdd");
14049                 ndr->depth++;
14050                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14051                 ndr->depth++;
14052                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14053                 ndr->depth--;
14054                 ndr_print_int32(ndr, "level", r->in.level);
14055                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
14056                 ndr_print_drsuapi_DsReplicaAddRequest(ndr, "req", &r->in.req);
14057                 ndr->depth--;
14058         }
14059         if (flags & NDR_OUT) {
14060                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaAdd");
14061                 ndr->depth++;
14062                 ndr_print_WERROR(ndr, "result", r->out.result);
14063                 ndr->depth--;
14064         }
14065         ndr->depth--;
14066 }
14067
14068 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDel(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaDel *r)
14069 {
14070         if (flags & NDR_IN) {
14071                 if (r->in.bind_handle == NULL) {
14072                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14073                 }
14074                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14075                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14076                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
14077                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14078         }
14079         if (flags & NDR_OUT) {
14080                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14081         }
14082         return NDR_ERR_SUCCESS;
14083 }
14084
14085 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDel(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaDel *r)
14086 {
14087         TALLOC_CTX *_mem_save_bind_handle_0;
14088         if (flags & NDR_IN) {
14089                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14090                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14091                 }
14092                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14093                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14094                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14095                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14096                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14097                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
14098                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14099         }
14100         if (flags & NDR_OUT) {
14101                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14102         }
14103         return NDR_ERR_SUCCESS;
14104 }
14105
14106 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r)
14107 {
14108         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDel");
14109         ndr->depth++;
14110         if (flags & NDR_SET_VALUES) {
14111                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14112         }
14113         if (flags & NDR_IN) {
14114                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaDel");
14115                 ndr->depth++;
14116                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14117                 ndr->depth++;
14118                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14119                 ndr->depth--;
14120                 ndr_print_int32(ndr, "level", r->in.level);
14121                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
14122                 ndr_print_drsuapi_DsReplicaDelRequest(ndr, "req", &r->in.req);
14123                 ndr->depth--;
14124         }
14125         if (flags & NDR_OUT) {
14126                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaDel");
14127                 ndr->depth++;
14128                 ndr_print_WERROR(ndr, "result", r->out.result);
14129                 ndr->depth--;
14130         }
14131         ndr->depth--;
14132 }
14133
14134 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMod(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaMod *r)
14135 {
14136         if (flags & NDR_IN) {
14137                 if (r->in.bind_handle == NULL) {
14138                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14139                 }
14140                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14141                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14142                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
14143                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14144         }
14145         if (flags & NDR_OUT) {
14146                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14147         }
14148         return NDR_ERR_SUCCESS;
14149 }
14150
14151 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMod(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaMod *r)
14152 {
14153         TALLOC_CTX *_mem_save_bind_handle_0;
14154         if (flags & NDR_IN) {
14155                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14156                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14157                 }
14158                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14159                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14160                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14161                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14162                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14163                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
14164                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
14165         }
14166         if (flags & NDR_OUT) {
14167                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14168         }
14169         return NDR_ERR_SUCCESS;
14170 }
14171
14172 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r)
14173 {
14174         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMod");
14175         ndr->depth++;
14176         if (flags & NDR_SET_VALUES) {
14177                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14178         }
14179         if (flags & NDR_IN) {
14180                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaMod");
14181                 ndr->depth++;
14182                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14183                 ndr->depth++;
14184                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14185                 ndr->depth--;
14186                 ndr_print_int32(ndr, "level", r->in.level);
14187                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
14188                 ndr_print_drsuapi_DsReplicaModRequest(ndr, "req", &r->in.req);
14189                 ndr->depth--;
14190         }
14191         if (flags & NDR_OUT) {
14192                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaMod");
14193                 ndr->depth++;
14194                 ndr_print_WERROR(ndr, "result", r->out.result);
14195                 ndr->depth--;
14196         }
14197         ndr->depth--;
14198 }
14199
14200 static enum ndr_err_code ndr_push_DRSUAPI_VERIFY_NAMES(struct ndr_push *ndr, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
14201 {
14202         if (flags & NDR_IN) {
14203         }
14204         if (flags & NDR_OUT) {
14205                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14206         }
14207         return NDR_ERR_SUCCESS;
14208 }
14209
14210 static enum ndr_err_code ndr_pull_DRSUAPI_VERIFY_NAMES(struct ndr_pull *ndr, int flags, struct DRSUAPI_VERIFY_NAMES *r)
14211 {
14212         if (flags & NDR_IN) {
14213         }
14214         if (flags & NDR_OUT) {
14215                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14216         }
14217         return NDR_ERR_SUCCESS;
14218 }
14219
14220 _PUBLIC_ void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
14221 {
14222         ndr_print_struct(ndr, name, "DRSUAPI_VERIFY_NAMES");
14223         ndr->depth++;
14224         if (flags & NDR_SET_VALUES) {
14225                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14226         }
14227         if (flags & NDR_IN) {
14228                 ndr_print_struct(ndr, "in", "DRSUAPI_VERIFY_NAMES");
14229                 ndr->depth++;
14230                 ndr->depth--;
14231         }
14232         if (flags & NDR_OUT) {
14233                 ndr_print_struct(ndr, "out", "DRSUAPI_VERIFY_NAMES");
14234                 ndr->depth++;
14235                 ndr_print_WERROR(ndr, "result", r->out.result);
14236                 ndr->depth--;
14237         }
14238         ndr->depth--;
14239 }
14240
14241 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships *r)
14242 {
14243         if (flags & NDR_IN) {
14244                 if (r->in.bind_handle == NULL) {
14245                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14246                 }
14247                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14248                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14249                 if (r->in.req == NULL) {
14250                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14251                 }
14252                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14253                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14254         }
14255         if (flags & NDR_OUT) {
14256                 if (r->out.level_out == NULL) {
14257                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14258                 }
14259                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14260                 if (r->out.ctr == NULL) {
14261                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14262                 }
14263                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14264                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14265                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14266         }
14267         return NDR_ERR_SUCCESS;
14268 }
14269
14270 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships *r)
14271 {
14272         TALLOC_CTX *_mem_save_bind_handle_0;
14273         TALLOC_CTX *_mem_save_req_0;
14274         TALLOC_CTX *_mem_save_level_out_0;
14275         TALLOC_CTX *_mem_save_ctr_0;
14276         if (flags & NDR_IN) {
14277                 ZERO_STRUCT(r->out);
14278
14279                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14280                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14281                 }
14282                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14283                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14284                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14285                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14286                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14287                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14288                         NDR_PULL_ALLOC(ndr, r->in.req);
14289                 }
14290                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14291                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14292                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14293                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14294                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14295                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14296                 ZERO_STRUCTP(r->out.level_out);
14297                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14298                 ZERO_STRUCTP(r->out.ctr);
14299         }
14300         if (flags & NDR_OUT) {
14301                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14302                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14303                 }
14304                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14305                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14306                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14307                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14308                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14309                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14310                 }
14311                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14312                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14313                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14314                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14315                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14316                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14317         }
14318         return NDR_ERR_SUCCESS;
14319 }
14320
14321 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r)
14322 {
14323         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships");
14324         ndr->depth++;
14325         if (flags & NDR_SET_VALUES) {
14326                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14327         }
14328         if (flags & NDR_IN) {
14329                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships");
14330                 ndr->depth++;
14331                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14332                 ndr->depth++;
14333                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14334                 ndr->depth--;
14335                 ndr_print_int32(ndr, "level", r->in.level);
14336                 ndr_print_ptr(ndr, "req", r->in.req);
14337                 ndr->depth++;
14338                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14339                 ndr_print_drsuapi_DsGetMembershipsRequest(ndr, "req", r->in.req);
14340                 ndr->depth--;
14341                 ndr->depth--;
14342         }
14343         if (flags & NDR_OUT) {
14344                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships");
14345                 ndr->depth++;
14346                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14347                 ndr->depth++;
14348                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14349                 ndr->depth--;
14350                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14351                 ndr->depth++;
14352                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14353                 ndr_print_drsuapi_DsGetMembershipsCtr(ndr, "ctr", r->out.ctr);
14354                 ndr->depth--;
14355                 ndr_print_WERROR(ndr, "result", r->out.result);
14356                 ndr->depth--;
14357         }
14358         ndr->depth--;
14359 }
14360
14361 static enum ndr_err_code ndr_push_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_push *ndr, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14362 {
14363         if (flags & NDR_IN) {
14364         }
14365         if (flags & NDR_OUT) {
14366                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14367         }
14368         return NDR_ERR_SUCCESS;
14369 }
14370
14371 static enum ndr_err_code ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_pull *ndr, int flags, struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14372 {
14373         if (flags & NDR_IN) {
14374         }
14375         if (flags & NDR_OUT) {
14376                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14377         }
14378         return NDR_ERR_SUCCESS;
14379 }
14380
14381 _PUBLIC_ void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14382 {
14383         ndr_print_struct(ndr, name, "DRSUAPI_INTER_DOMAIN_MOVE");
14384         ndr->depth++;
14385         if (flags & NDR_SET_VALUES) {
14386                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14387         }
14388         if (flags & NDR_IN) {
14389                 ndr_print_struct(ndr, "in", "DRSUAPI_INTER_DOMAIN_MOVE");
14390                 ndr->depth++;
14391                 ndr->depth--;
14392         }
14393         if (flags & NDR_OUT) {
14394                 ndr_print_struct(ndr, "out", "DRSUAPI_INTER_DOMAIN_MOVE");
14395                 ndr->depth++;
14396                 ndr_print_WERROR(ndr, "result", r->out.result);
14397                 ndr->depth--;
14398         }
14399         ndr->depth--;
14400 }
14401
14402 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLog(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14403 {
14404         if (flags & NDR_IN) {
14405                 if (r->in.bind_handle == NULL) {
14406                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14407                 }
14408                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14409                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14410                 if (r->in.req == NULL) {
14411                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14412                 }
14413                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14414                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14415         }
14416         if (flags & NDR_OUT) {
14417                 if (r->out.level_out == NULL) {
14418                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14419                 }
14420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14421                 if (r->out.info == NULL) {
14422                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14423                 }
14424                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.level_out));
14425                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14426                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14427         }
14428         return NDR_ERR_SUCCESS;
14429 }
14430
14431 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLog(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNT4ChangeLog *r)
14432 {
14433         TALLOC_CTX *_mem_save_bind_handle_0;
14434         TALLOC_CTX *_mem_save_req_0;
14435         TALLOC_CTX *_mem_save_level_out_0;
14436         TALLOC_CTX *_mem_save_info_0;
14437         if (flags & NDR_IN) {
14438                 ZERO_STRUCT(r->out);
14439
14440                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14441                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14442                 }
14443                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14444                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14445                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14446                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14448                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14449                         NDR_PULL_ALLOC(ndr, r->in.req);
14450                 }
14451                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14452                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14453                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14454                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14455                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14456                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14457                 ZERO_STRUCTP(r->out.level_out);
14458                 NDR_PULL_ALLOC(ndr, r->out.info);
14459                 ZERO_STRUCTP(r->out.info);
14460         }
14461         if (flags & NDR_OUT) {
14462                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14463                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14464                 }
14465                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14466                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14468                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14469                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14470                         NDR_PULL_ALLOC(ndr, r->out.info);
14471                 }
14472                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14473                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14474                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.level_out));
14475                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14476                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14477                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14478         }
14479         return NDR_ERR_SUCCESS;
14480 }
14481
14482 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLog(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14483 {
14484         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLog");
14485         ndr->depth++;
14486         if (flags & NDR_SET_VALUES) {
14487                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14488         }
14489         if (flags & NDR_IN) {
14490                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNT4ChangeLog");
14491                 ndr->depth++;
14492                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14493                 ndr->depth++;
14494                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14495                 ndr->depth--;
14496                 ndr_print_uint32(ndr, "level", r->in.level);
14497                 ndr_print_ptr(ndr, "req", r->in.req);
14498                 ndr->depth++;
14499                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14500                 ndr_print_drsuapi_DsGetNT4ChangeLogRequest(ndr, "req", r->in.req);
14501                 ndr->depth--;
14502                 ndr->depth--;
14503         }
14504         if (flags & NDR_OUT) {
14505                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNT4ChangeLog");
14506                 ndr->depth++;
14507                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14508                 ndr->depth++;
14509                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14510                 ndr->depth--;
14511                 ndr_print_ptr(ndr, "info", r->out.info);
14512                 ndr->depth++;
14513                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.level_out);
14514                 ndr_print_drsuapi_DsGetNT4ChangeLogInfo(ndr, "info", r->out.info);
14515                 ndr->depth--;
14516                 ndr_print_WERROR(ndr, "result", r->out.result);
14517                 ndr->depth--;
14518         }
14519         ndr->depth--;
14520 }
14521
14522 static enum ndr_err_code ndr_push_drsuapi_DsCrackNames(struct ndr_push *ndr, int flags, const struct drsuapi_DsCrackNames *r)
14523 {
14524         if (flags & NDR_IN) {
14525                 if (r->in.bind_handle == NULL) {
14526                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14527                 }
14528                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14529                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14530                 if (r->in.req == NULL) {
14531                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14532                 }
14533                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14534                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14535         }
14536         if (flags & NDR_OUT) {
14537                 if (r->out.level_out == NULL) {
14538                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14539                 }
14540                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14541                 if (r->out.ctr == NULL) {
14542                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14543                 }
14544                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14545                 NDR_CHECK(ndr_push_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14546                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14547         }
14548         return NDR_ERR_SUCCESS;
14549 }
14550
14551 static enum ndr_err_code ndr_pull_drsuapi_DsCrackNames(struct ndr_pull *ndr, int flags, struct drsuapi_DsCrackNames *r)
14552 {
14553         TALLOC_CTX *_mem_save_bind_handle_0;
14554         TALLOC_CTX *_mem_save_req_0;
14555         TALLOC_CTX *_mem_save_level_out_0;
14556         TALLOC_CTX *_mem_save_ctr_0;
14557         if (flags & NDR_IN) {
14558                 ZERO_STRUCT(r->out);
14559
14560                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14561                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14562                 }
14563                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14564                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14565                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14566                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14567                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14568                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14569                         NDR_PULL_ALLOC(ndr, r->in.req);
14570                 }
14571                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14572                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14573                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14574                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14575                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14576                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14577                 ZERO_STRUCTP(r->out.level_out);
14578                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14579                 ZERO_STRUCTP(r->out.ctr);
14580         }
14581         if (flags & NDR_OUT) {
14582                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14583                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14584                 }
14585                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14586                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14587                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14588                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14589                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14590                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14591                 }
14592                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14593                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14594                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14595                 NDR_CHECK(ndr_pull_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14596                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14597                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14598         }
14599         return NDR_ERR_SUCCESS;
14600 }
14601
14602 _PUBLIC_ void ndr_print_drsuapi_DsCrackNames(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsCrackNames *r)
14603 {
14604         ndr_print_struct(ndr, name, "drsuapi_DsCrackNames");
14605         ndr->depth++;
14606         if (flags & NDR_SET_VALUES) {
14607                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14608         }
14609         if (flags & NDR_IN) {
14610                 ndr_print_struct(ndr, "in", "drsuapi_DsCrackNames");
14611                 ndr->depth++;
14612                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14613                 ndr->depth++;
14614                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14615                 ndr->depth--;
14616                 ndr_print_int32(ndr, "level", r->in.level);
14617                 ndr_print_ptr(ndr, "req", r->in.req);
14618                 ndr->depth++;
14619                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14620                 ndr_print_drsuapi_DsNameRequest(ndr, "req", r->in.req);
14621                 ndr->depth--;
14622                 ndr->depth--;
14623         }
14624         if (flags & NDR_OUT) {
14625                 ndr_print_struct(ndr, "out", "drsuapi_DsCrackNames");
14626                 ndr->depth++;
14627                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14628                 ndr->depth++;
14629                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14630                 ndr->depth--;
14631                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14632                 ndr->depth++;
14633                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14634                 ndr_print_drsuapi_DsNameCtr(ndr, "ctr", r->out.ctr);
14635                 ndr->depth--;
14636                 ndr_print_WERROR(ndr, "result", r->out.result);
14637                 ndr->depth--;
14638         }
14639         ndr->depth--;
14640 }
14641
14642 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpn(struct ndr_push *ndr, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14643 {
14644         if (flags & NDR_IN) {
14645                 if (r->in.bind_handle == NULL) {
14646                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14647                 }
14648                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14649                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14650                 if (r->in.req == NULL) {
14651                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14652                 }
14653                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14654                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14655         }
14656         if (flags & NDR_OUT) {
14657                 if (r->out.level_out == NULL) {
14658                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14659                 }
14660                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14661                 if (r->out.res == NULL) {
14662                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14663                 }
14664                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14665                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14666                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14667         }
14668         return NDR_ERR_SUCCESS;
14669 }
14670
14671 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpn(struct ndr_pull *ndr, int flags, struct drsuapi_DsWriteAccountSpn *r)
14672 {
14673         TALLOC_CTX *_mem_save_bind_handle_0;
14674         TALLOC_CTX *_mem_save_req_0;
14675         TALLOC_CTX *_mem_save_level_out_0;
14676         TALLOC_CTX *_mem_save_res_0;
14677         if (flags & NDR_IN) {
14678                 ZERO_STRUCT(r->out);
14679
14680                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14681                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14682                 }
14683                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14684                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14685                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14686                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14687                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14688                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14689                         NDR_PULL_ALLOC(ndr, r->in.req);
14690                 }
14691                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14692                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14693                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14694                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14695                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14696                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14697                 ZERO_STRUCTP(r->out.level_out);
14698                 NDR_PULL_ALLOC(ndr, r->out.res);
14699                 ZERO_STRUCTP(r->out.res);
14700         }
14701         if (flags & NDR_OUT) {
14702                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14703                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14704                 }
14705                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14706                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14707                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14708                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14709                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14710                         NDR_PULL_ALLOC(ndr, r->out.res);
14711                 }
14712                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14713                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14714                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14715                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14716                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14717                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14718         }
14719         return NDR_ERR_SUCCESS;
14720 }
14721
14722 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpn(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14723 {
14724         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpn");
14725         ndr->depth++;
14726         if (flags & NDR_SET_VALUES) {
14727                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14728         }
14729         if (flags & NDR_IN) {
14730                 ndr_print_struct(ndr, "in", "drsuapi_DsWriteAccountSpn");
14731                 ndr->depth++;
14732                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14733                 ndr->depth++;
14734                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14735                 ndr->depth--;
14736                 ndr_print_int32(ndr, "level", r->in.level);
14737                 ndr_print_ptr(ndr, "req", r->in.req);
14738                 ndr->depth++;
14739                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14740                 ndr_print_drsuapi_DsWriteAccountSpnRequest(ndr, "req", r->in.req);
14741                 ndr->depth--;
14742                 ndr->depth--;
14743         }
14744         if (flags & NDR_OUT) {
14745                 ndr_print_struct(ndr, "out", "drsuapi_DsWriteAccountSpn");
14746                 ndr->depth++;
14747                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14748                 ndr->depth++;
14749                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14750                 ndr->depth--;
14751                 ndr_print_ptr(ndr, "res", r->out.res);
14752                 ndr->depth++;
14753                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14754                 ndr_print_drsuapi_DsWriteAccountSpnResult(ndr, "res", r->out.res);
14755                 ndr->depth--;
14756                 ndr_print_WERROR(ndr, "result", r->out.result);
14757                 ndr->depth--;
14758         }
14759         ndr->depth--;
14760 }
14761
14762 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServer(struct ndr_push *ndr, int flags, const struct drsuapi_DsRemoveDSServer *r)
14763 {
14764         if (flags & NDR_IN) {
14765                 if (r->in.bind_handle == NULL) {
14766                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14767                 }
14768                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14769                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14770                 if (r->in.req == NULL) {
14771                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14772                 }
14773                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14774                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14775         }
14776         if (flags & NDR_OUT) {
14777                 if (r->out.level_out == NULL) {
14778                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14779                 }
14780                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14781                 if (r->out.res == NULL) {
14782                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14783                 }
14784                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14785                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14786                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14787         }
14788         return NDR_ERR_SUCCESS;
14789 }
14790
14791 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServer(struct ndr_pull *ndr, int flags, struct drsuapi_DsRemoveDSServer *r)
14792 {
14793         TALLOC_CTX *_mem_save_bind_handle_0;
14794         TALLOC_CTX *_mem_save_req_0;
14795         TALLOC_CTX *_mem_save_level_out_0;
14796         TALLOC_CTX *_mem_save_res_0;
14797         if (flags & NDR_IN) {
14798                 ZERO_STRUCT(r->out);
14799
14800                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14801                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14802                 }
14803                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14804                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14805                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14806                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14807                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14808                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14809                         NDR_PULL_ALLOC(ndr, r->in.req);
14810                 }
14811                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14812                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14813                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14814                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14815                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14816                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14817                 ZERO_STRUCTP(r->out.level_out);
14818                 NDR_PULL_ALLOC(ndr, r->out.res);
14819                 ZERO_STRUCTP(r->out.res);
14820         }
14821         if (flags & NDR_OUT) {
14822                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14823                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14824                 }
14825                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14826                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14827                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14828                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14829                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14830                         NDR_PULL_ALLOC(ndr, r->out.res);
14831                 }
14832                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14833                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14834                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14835                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14836                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14837                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14838         }
14839         return NDR_ERR_SUCCESS;
14840 }
14841
14842 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServer(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsRemoveDSServer *r)
14843 {
14844         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServer");
14845         ndr->depth++;
14846         if (flags & NDR_SET_VALUES) {
14847                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14848         }
14849         if (flags & NDR_IN) {
14850                 ndr_print_struct(ndr, "in", "drsuapi_DsRemoveDSServer");
14851                 ndr->depth++;
14852                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14853                 ndr->depth++;
14854                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14855                 ndr->depth--;
14856                 ndr_print_int32(ndr, "level", r->in.level);
14857                 ndr_print_ptr(ndr, "req", r->in.req);
14858                 ndr->depth++;
14859                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14860                 ndr_print_drsuapi_DsRemoveDSServerRequest(ndr, "req", r->in.req);
14861                 ndr->depth--;
14862                 ndr->depth--;
14863         }
14864         if (flags & NDR_OUT) {
14865                 ndr_print_struct(ndr, "out", "drsuapi_DsRemoveDSServer");
14866                 ndr->depth++;
14867                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14868                 ndr->depth++;
14869                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14870                 ndr->depth--;
14871                 ndr_print_ptr(ndr, "res", r->out.res);
14872                 ndr->depth++;
14873                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14874                 ndr_print_drsuapi_DsRemoveDSServerResult(ndr, "res", r->out.res);
14875                 ndr->depth--;
14876                 ndr_print_WERROR(ndr, "result", r->out.result);
14877                 ndr->depth--;
14878         }
14879         ndr->depth--;
14880 }
14881
14882 static enum ndr_err_code ndr_push_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_push *ndr, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14883 {
14884         if (flags & NDR_IN) {
14885         }
14886         if (flags & NDR_OUT) {
14887                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14888         }
14889         return NDR_ERR_SUCCESS;
14890 }
14891
14892 static enum ndr_err_code ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_pull *ndr, int flags, struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14893 {
14894         if (flags & NDR_IN) {
14895         }
14896         if (flags & NDR_OUT) {
14897                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14898         }
14899         return NDR_ERR_SUCCESS;
14900 }
14901
14902 _PUBLIC_ void ndr_print_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14903 {
14904         ndr_print_struct(ndr, name, "DRSUAPI_REMOVE_DS_DOMAIN");
14905         ndr->depth++;
14906         if (flags & NDR_SET_VALUES) {
14907                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14908         }
14909         if (flags & NDR_IN) {
14910                 ndr_print_struct(ndr, "in", "DRSUAPI_REMOVE_DS_DOMAIN");
14911                 ndr->depth++;
14912                 ndr->depth--;
14913         }
14914         if (flags & NDR_OUT) {
14915                 ndr_print_struct(ndr, "out", "DRSUAPI_REMOVE_DS_DOMAIN");
14916                 ndr->depth++;
14917                 ndr_print_WERROR(ndr, "result", r->out.result);
14918                 ndr->depth--;
14919         }
14920         ndr->depth--;
14921 }
14922
14923 static enum ndr_err_code ndr_push_drsuapi_DsGetDomainControllerInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14924 {
14925         if (flags & NDR_IN) {
14926                 if (r->in.bind_handle == NULL) {
14927                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14928                 }
14929                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14930                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14931                 if (r->in.req == NULL) {
14932                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14933                 }
14934                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14935                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14936         }
14937         if (flags & NDR_OUT) {
14938                 if (r->out.level_out == NULL) {
14939                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14940                 }
14941                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14942                 if (r->out.ctr == NULL) {
14943                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14944                 }
14945                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14946                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14947                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14948         }
14949         return NDR_ERR_SUCCESS;
14950 }
14951
14952 static enum ndr_err_code ndr_pull_drsuapi_DsGetDomainControllerInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetDomainControllerInfo *r)
14953 {
14954         TALLOC_CTX *_mem_save_bind_handle_0;
14955         TALLOC_CTX *_mem_save_req_0;
14956         TALLOC_CTX *_mem_save_level_out_0;
14957         TALLOC_CTX *_mem_save_ctr_0;
14958         if (flags & NDR_IN) {
14959                 ZERO_STRUCT(r->out);
14960
14961                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14962                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14963                 }
14964                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14965                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14966                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14967                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14968                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14969                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14970                         NDR_PULL_ALLOC(ndr, r->in.req);
14971                 }
14972                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14973                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14974                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14975                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14976                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14977                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14978                 ZERO_STRUCTP(r->out.level_out);
14979                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14980                 ZERO_STRUCTP(r->out.ctr);
14981         }
14982         if (flags & NDR_OUT) {
14983                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14984                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14985                 }
14986                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14987                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14988                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14989                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14990                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14991                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14992                 }
14993                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14994                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14995                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14996                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14997                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14998                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14999         }
15000         return NDR_ERR_SUCCESS;
15001 }
15002
15003 _PUBLIC_ void ndr_print_drsuapi_DsGetDomainControllerInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
15004 {
15005         ndr_print_struct(ndr, name, "drsuapi_DsGetDomainControllerInfo");
15006         ndr->depth++;
15007         if (flags & NDR_SET_VALUES) {
15008                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15009         }
15010         if (flags & NDR_IN) {
15011                 ndr_print_struct(ndr, "in", "drsuapi_DsGetDomainControllerInfo");
15012                 ndr->depth++;
15013                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15014                 ndr->depth++;
15015                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15016                 ndr->depth--;
15017                 ndr_print_int32(ndr, "level", r->in.level);
15018                 ndr_print_ptr(ndr, "req", r->in.req);
15019                 ndr->depth++;
15020                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15021                 ndr_print_drsuapi_DsGetDCInfoRequest(ndr, "req", r->in.req);
15022                 ndr->depth--;
15023                 ndr->depth--;
15024         }
15025         if (flags & NDR_OUT) {
15026                 ndr_print_struct(ndr, "out", "drsuapi_DsGetDomainControllerInfo");
15027                 ndr->depth++;
15028                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15029                 ndr->depth++;
15030                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15031                 ndr->depth--;
15032                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15033                 ndr->depth++;
15034                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15035                 ndr_print_drsuapi_DsGetDCInfoCtr(ndr, "ctr", r->out.ctr);
15036                 ndr->depth--;
15037                 ndr_print_WERROR(ndr, "result", r->out.result);
15038                 ndr->depth--;
15039         }
15040         ndr->depth--;
15041 }
15042
15043 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAddEntry(struct ndr_push *ndr, int flags, const struct drsuapi_DsAddEntry *r)
15044 {
15045         if (flags & NDR_IN) {
15046                 if (r->in.bind_handle == NULL) {
15047                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15048                 }
15049                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15050                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15051                 if (r->in.req == NULL) {
15052                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15053                 }
15054                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15055                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15056         }
15057         if (flags & NDR_OUT) {
15058                 if (r->out.level_out == NULL) {
15059                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15060                 }
15061                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15062                 if (r->out.ctr == NULL) {
15063                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15064                 }
15065                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15066                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15067                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15068         }
15069         return NDR_ERR_SUCCESS;
15070 }
15071
15072 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAddEntry(struct ndr_pull *ndr, int flags, struct drsuapi_DsAddEntry *r)
15073 {
15074         TALLOC_CTX *_mem_save_bind_handle_0;
15075         TALLOC_CTX *_mem_save_req_0;
15076         TALLOC_CTX *_mem_save_level_out_0;
15077         TALLOC_CTX *_mem_save_ctr_0;
15078         if (flags & NDR_IN) {
15079                 ZERO_STRUCT(r->out);
15080
15081                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15082                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15083                 }
15084                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15085                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15086                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15087                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15088                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15089                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15090                         NDR_PULL_ALLOC(ndr, r->in.req);
15091                 }
15092                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15093                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15094                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15095                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15096                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15097                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15098                 ZERO_STRUCTP(r->out.level_out);
15099                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15100                 ZERO_STRUCTP(r->out.ctr);
15101         }
15102         if (flags & NDR_OUT) {
15103                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15104                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15105                 }
15106                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15107                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15108                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15109                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15110                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15111                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15112                 }
15113                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15114                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15115                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15116                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15117                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15118                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15119         }
15120         return NDR_ERR_SUCCESS;
15121 }
15122
15123 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsAddEntry *r)
15124 {
15125         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry");
15126         ndr->depth++;
15127         if (flags & NDR_SET_VALUES) {
15128                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15129         }
15130         if (flags & NDR_IN) {
15131                 ndr_print_struct(ndr, "in", "drsuapi_DsAddEntry");
15132                 ndr->depth++;
15133                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15134                 ndr->depth++;
15135                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15136                 ndr->depth--;
15137                 ndr_print_int32(ndr, "level", r->in.level);
15138                 ndr_print_ptr(ndr, "req", r->in.req);
15139                 ndr->depth++;
15140                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15141                 ndr_print_drsuapi_DsAddEntryRequest(ndr, "req", r->in.req);
15142                 ndr->depth--;
15143                 ndr->depth--;
15144         }
15145         if (flags & NDR_OUT) {
15146                 ndr_print_struct(ndr, "out", "drsuapi_DsAddEntry");
15147                 ndr->depth++;
15148                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15149                 ndr->depth++;
15150                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15151                 ndr->depth--;
15152                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15153                 ndr->depth++;
15154                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15155                 ndr_print_drsuapi_DsAddEntryCtr(ndr, "ctr", r->out.ctr);
15156                 ndr->depth--;
15157                 ndr_print_WERROR(ndr, "result", r->out.result);
15158                 ndr->depth--;
15159         }
15160         ndr->depth--;
15161 }
15162
15163 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC(struct ndr_push *ndr, int flags, const struct drsuapi_DsExecuteKCC *r)
15164 {
15165         if (flags & NDR_IN) {
15166                 if (r->in.bind_handle == NULL) {
15167                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15168                 }
15169                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15171                 if (r->in.req == NULL) {
15172                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15173                 }
15174                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15175                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
15176         }
15177         if (flags & NDR_OUT) {
15178                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15179         }
15180         return NDR_ERR_SUCCESS;
15181 }
15182
15183 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC(struct ndr_pull *ndr, int flags, struct drsuapi_DsExecuteKCC *r)
15184 {
15185         TALLOC_CTX *_mem_save_bind_handle_0;
15186         TALLOC_CTX *_mem_save_req_0;
15187         if (flags & NDR_IN) {
15188                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15189                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15190                 }
15191                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15192                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15193                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15194                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15196                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15197                         NDR_PULL_ALLOC(ndr, r->in.req);
15198                 }
15199                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15200                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15201                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15202                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
15203                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15204         }
15205         if (flags & NDR_OUT) {
15206                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15207         }
15208         return NDR_ERR_SUCCESS;
15209 }
15210
15211 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsExecuteKCC *r)
15212 {
15213         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC");
15214         ndr->depth++;
15215         if (flags & NDR_SET_VALUES) {
15216                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15217         }
15218         if (flags & NDR_IN) {
15219                 ndr_print_struct(ndr, "in", "drsuapi_DsExecuteKCC");
15220                 ndr->depth++;
15221                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15222                 ndr->depth++;
15223                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15224                 ndr->depth--;
15225                 ndr_print_uint32(ndr, "level", r->in.level);
15226                 ndr_print_ptr(ndr, "req", r->in.req);
15227                 ndr->depth++;
15228                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15229                 ndr_print_drsuapi_DsExecuteKCCRequest(ndr, "req", r->in.req);
15230                 ndr->depth--;
15231                 ndr->depth--;
15232         }
15233         if (flags & NDR_OUT) {
15234                 ndr_print_struct(ndr, "out", "drsuapi_DsExecuteKCC");
15235                 ndr->depth++;
15236                 ndr_print_WERROR(ndr, "result", r->out.result);
15237                 ndr->depth--;
15238         }
15239         ndr->depth--;
15240 }
15241
15242 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaGetInfo *r)
15243 {
15244         if (flags & NDR_IN) {
15245                 if (r->in.bind_handle == NULL) {
15246                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15247                 }
15248                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15249                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, r->in.level));
15250                 if (r->in.req == NULL) {
15251                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15252                 }
15253                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15254                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15255         }
15256         if (flags & NDR_OUT) {
15257                 if (r->out.info_type == NULL) {
15258                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15259                 }
15260                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, *r->out.info_type));
15261                 if (r->out.info == NULL) {
15262                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15263                 }
15264                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.info_type));
15265                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15266                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15267         }
15268         return NDR_ERR_SUCCESS;
15269 }
15270
15271 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaGetInfo *r)
15272 {
15273         TALLOC_CTX *_mem_save_bind_handle_0;
15274         TALLOC_CTX *_mem_save_req_0;
15275         TALLOC_CTX *_mem_save_info_type_0;
15276         TALLOC_CTX *_mem_save_info_0;
15277         if (flags & NDR_IN) {
15278                 ZERO_STRUCT(r->out);
15279
15280                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15281                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15282                 }
15283                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15284                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15285                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15286                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15287                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, &r->in.level));
15288                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15289                         NDR_PULL_ALLOC(ndr, r->in.req);
15290                 }
15291                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15292                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15293                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15294                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15295                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15296                 NDR_PULL_ALLOC(ndr, r->out.info_type);
15297                 ZERO_STRUCTP(r->out.info_type);
15298                 NDR_PULL_ALLOC(ndr, r->out.info);
15299                 ZERO_STRUCTP(r->out.info);
15300         }
15301         if (flags & NDR_OUT) {
15302                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15303                         NDR_PULL_ALLOC(ndr, r->out.info_type);
15304                 }
15305                 _mem_save_info_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
15306                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_type, LIBNDR_FLAG_REF_ALLOC);
15307                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->out.info_type));
15308                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_type_0, LIBNDR_FLAG_REF_ALLOC);
15309                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15310                         NDR_PULL_ALLOC(ndr, r->out.info);
15311                 }
15312                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15313                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
15314                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.info_type));
15315                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15316                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15317                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15318         }
15319         return NDR_ERR_SUCCESS;
15320 }
15321
15322 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaGetInfo *r)
15323 {
15324         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfo");
15325         ndr->depth++;
15326         if (flags & NDR_SET_VALUES) {
15327                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15328         }
15329         if (flags & NDR_IN) {
15330                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaGetInfo");
15331                 ndr->depth++;
15332                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15333                 ndr->depth++;
15334                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15335                 ndr->depth--;
15336                 ndr_print_drsuapi_DsReplicaGetInfoLevel(ndr, "level", r->in.level);
15337                 ndr_print_ptr(ndr, "req", r->in.req);
15338                 ndr->depth++;
15339                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15340                 ndr_print_drsuapi_DsReplicaGetInfoRequest(ndr, "req", r->in.req);
15341                 ndr->depth--;
15342                 ndr->depth--;
15343         }
15344         if (flags & NDR_OUT) {
15345                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaGetInfo");
15346                 ndr->depth++;
15347                 ndr_print_ptr(ndr, "info_type", r->out.info_type);
15348                 ndr->depth++;
15349                 ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", *r->out.info_type);
15350                 ndr->depth--;
15351                 ndr_print_ptr(ndr, "info", r->out.info);
15352                 ndr->depth++;
15353                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.info_type);
15354                 ndr_print_drsuapi_DsReplicaInfo(ndr, "info", r->out.info);
15355                 ndr->depth--;
15356                 ndr_print_WERROR(ndr, "result", r->out.result);
15357                 ndr->depth--;
15358         }
15359         ndr->depth--;
15360 }
15361
15362 static enum ndr_err_code ndr_push_DRSUAPI_ADD_SID_HISTORY(struct ndr_push *ndr, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15363 {
15364         if (flags & NDR_IN) {
15365         }
15366         if (flags & NDR_OUT) {
15367                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15368         }
15369         return NDR_ERR_SUCCESS;
15370 }
15371
15372 static enum ndr_err_code ndr_pull_DRSUAPI_ADD_SID_HISTORY(struct ndr_pull *ndr, int flags, struct DRSUAPI_ADD_SID_HISTORY *r)
15373 {
15374         if (flags & NDR_IN) {
15375         }
15376         if (flags & NDR_OUT) {
15377                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15378         }
15379         return NDR_ERR_SUCCESS;
15380 }
15381
15382 _PUBLIC_ void ndr_print_DRSUAPI_ADD_SID_HISTORY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15383 {
15384         ndr_print_struct(ndr, name, "DRSUAPI_ADD_SID_HISTORY");
15385         ndr->depth++;
15386         if (flags & NDR_SET_VALUES) {
15387                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15388         }
15389         if (flags & NDR_IN) {
15390                 ndr_print_struct(ndr, "in", "DRSUAPI_ADD_SID_HISTORY");
15391                 ndr->depth++;
15392                 ndr->depth--;
15393         }
15394         if (flags & NDR_OUT) {
15395                 ndr_print_struct(ndr, "out", "DRSUAPI_ADD_SID_HISTORY");
15396                 ndr->depth++;
15397                 ndr_print_WERROR(ndr, "result", r->out.result);
15398                 ndr->depth--;
15399         }
15400         ndr->depth--;
15401 }
15402
15403 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships2 *r)
15404 {
15405         if (flags & NDR_IN) {
15406                 if (r->in.bind_handle == NULL) {
15407                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15408                 }
15409                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15410                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15411                 if (r->in.req == NULL) {
15412                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15413                 }
15414                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15415                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15416         }
15417         if (flags & NDR_OUT) {
15418                 if (r->out.level_out == NULL) {
15419                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15420                 }
15421                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15422                 if (r->out.ctr == NULL) {
15423                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15424                 }
15425                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15426                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15427                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15428         }
15429         return NDR_ERR_SUCCESS;
15430 }
15431
15432 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships2 *r)
15433 {
15434         TALLOC_CTX *_mem_save_bind_handle_0;
15435         TALLOC_CTX *_mem_save_req_0;
15436         TALLOC_CTX *_mem_save_level_out_0;
15437         TALLOC_CTX *_mem_save_ctr_0;
15438         if (flags & NDR_IN) {
15439                 ZERO_STRUCT(r->out);
15440
15441                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15442                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15443                 }
15444                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15445                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15446                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15447                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15448                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15449                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15450                         NDR_PULL_ALLOC(ndr, r->in.req);
15451                 }
15452                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15453                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15454                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15455                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15456                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15457                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15458                 ZERO_STRUCTP(r->out.level_out);
15459                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15460                 ZERO_STRUCTP(r->out.ctr);
15461         }
15462         if (flags & NDR_OUT) {
15463                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15464                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15465                 }
15466                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15467                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15468                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15469                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15470                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15471                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15472                 }
15473                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15474                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15475                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15476                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15477                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15478                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15479         }
15480         return NDR_ERR_SUCCESS;
15481 }
15482
15483 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships2 *r)
15484 {
15485         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2");
15486         ndr->depth++;
15487         if (flags & NDR_SET_VALUES) {
15488                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15489         }
15490         if (flags & NDR_IN) {
15491                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships2");
15492                 ndr->depth++;
15493                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15494                 ndr->depth++;
15495                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15496                 ndr->depth--;
15497                 ndr_print_int32(ndr, "level", r->in.level);
15498                 ndr_print_ptr(ndr, "req", r->in.req);
15499                 ndr->depth++;
15500                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15501                 ndr_print_drsuapi_DsGetMemberships2Request(ndr, "req", r->in.req);
15502                 ndr->depth--;
15503                 ndr->depth--;
15504         }
15505         if (flags & NDR_OUT) {
15506                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships2");
15507                 ndr->depth++;
15508                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15509                 ndr->depth++;
15510                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15511                 ndr->depth--;
15512                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15513                 ndr->depth++;
15514                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15515                 ndr_print_drsuapi_DsGetMemberships2Ctr(ndr, "ctr", r->out.ctr);
15516                 ndr->depth--;
15517                 ndr_print_WERROR(ndr, "result", r->out.result);
15518                 ndr->depth--;
15519         }
15520         ndr->depth--;
15521 }
15522
15523 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15524 {
15525         if (flags & NDR_IN) {
15526         }
15527         if (flags & NDR_OUT) {
15528                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15529         }
15530         return NDR_ERR_SUCCESS;
15531 }
15532
15533 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15534 {
15535         if (flags & NDR_IN) {
15536         }
15537         if (flags & NDR_OUT) {
15538                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15539         }
15540         return NDR_ERR_SUCCESS;
15541 }
15542
15543 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15544 {
15545         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15546         ndr->depth++;
15547         if (flags & NDR_SET_VALUES) {
15548                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15549         }
15550         if (flags & NDR_IN) {
15551                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15552                 ndr->depth++;
15553                 ndr->depth--;
15554         }
15555         if (flags & NDR_OUT) {
15556                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15557                 ndr->depth++;
15558                 ndr_print_WERROR(ndr, "result", r->out.result);
15559                 ndr->depth--;
15560         }
15561         ndr->depth--;
15562 }
15563
15564 static enum ndr_err_code ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_push *ndr, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15565 {
15566         if (flags & NDR_IN) {
15567         }
15568         if (flags & NDR_OUT) {
15569                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15570         }
15571         return NDR_ERR_SUCCESS;
15572 }
15573
15574 static enum ndr_err_code ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_pull *ndr, int flags, struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15575 {
15576         if (flags & NDR_IN) {
15577         }
15578         if (flags & NDR_OUT) {
15579                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15580         }
15581         return NDR_ERR_SUCCESS;
15582 }
15583
15584 _PUBLIC_ void ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15585 {
15586         ndr_print_struct(ndr, name, "DRSUAPI_GET_OBJECT_EXISTENCE");
15587         ndr->depth++;
15588         if (flags & NDR_SET_VALUES) {
15589                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15590         }
15591         if (flags & NDR_IN) {
15592                 ndr_print_struct(ndr, "in", "DRSUAPI_GET_OBJECT_EXISTENCE");
15593                 ndr->depth++;
15594                 ndr->depth--;
15595         }
15596         if (flags & NDR_OUT) {
15597                 ndr_print_struct(ndr, "out", "DRSUAPI_GET_OBJECT_EXISTENCE");
15598                 ndr->depth++;
15599                 ndr_print_WERROR(ndr, "result", r->out.result);
15600                 ndr->depth--;
15601         }
15602         ndr->depth--;
15603 }
15604
15605 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCost(struct ndr_push *ndr, int flags, const struct drsuapi_QuerySitesByCost *r)
15606 {
15607         if (flags & NDR_IN) {
15608                 if (r->in.bind_handle == NULL) {
15609                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15610                 }
15611                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15612                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15613                 if (r->in.req == NULL) {
15614                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15615                 }
15616                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15617                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15618         }
15619         if (flags & NDR_OUT) {
15620                 if (r->out.level_out == NULL) {
15621                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15622                 }
15623                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15624                 if (r->out.ctr == NULL) {
15625                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15626                 }
15627                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15628                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15629                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15630         }
15631         return NDR_ERR_SUCCESS;
15632 }
15633
15634 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCost(struct ndr_pull *ndr, int flags, struct drsuapi_QuerySitesByCost *r)
15635 {
15636         TALLOC_CTX *_mem_save_bind_handle_0;
15637         TALLOC_CTX *_mem_save_req_0;
15638         TALLOC_CTX *_mem_save_level_out_0;
15639         TALLOC_CTX *_mem_save_ctr_0;
15640         if (flags & NDR_IN) {
15641                 ZERO_STRUCT(r->out);
15642
15643                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15644                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15645                 }
15646                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15647                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15648                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15649                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15650                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15651                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15652                         NDR_PULL_ALLOC(ndr, r->in.req);
15653                 }
15654                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15655                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15656                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15657                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15658                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15659                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15660                 ZERO_STRUCTP(r->out.level_out);
15661                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15662                 ZERO_STRUCTP(r->out.ctr);
15663         }
15664         if (flags & NDR_OUT) {
15665                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15666                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15667                 }
15668                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15669                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15670                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15671                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15672                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15673                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15674                 }
15675                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15676                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15677                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15678                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15679                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15680                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15681         }
15682         return NDR_ERR_SUCCESS;
15683 }
15684
15685 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCost(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_QuerySitesByCost *r)
15686 {
15687         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCost");
15688         ndr->depth++;
15689         if (flags & NDR_SET_VALUES) {
15690                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15691         }
15692         if (flags & NDR_IN) {
15693                 ndr_print_struct(ndr, "in", "drsuapi_QuerySitesByCost");
15694                 ndr->depth++;
15695                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15696                 ndr->depth++;
15697                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15698                 ndr->depth--;
15699                 ndr_print_int32(ndr, "level", r->in.level);
15700                 ndr_print_ptr(ndr, "req", r->in.req);
15701                 ndr->depth++;
15702                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15703                 ndr_print_drsuapi_QuerySitesByCostRequest(ndr, "req", r->in.req);
15704                 ndr->depth--;
15705                 ndr->depth--;
15706         }
15707         if (flags & NDR_OUT) {
15708                 ndr_print_struct(ndr, "out", "drsuapi_QuerySitesByCost");
15709                 ndr->depth++;
15710                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15711                 ndr->depth++;
15712                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15713                 ndr->depth--;
15714                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15715                 ndr->depth++;
15716                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15717                 ndr_print_drsuapi_QuerySitesByCostCtr(ndr, "ctr", r->out.ctr);
15718                 ndr->depth--;
15719                 ndr_print_WERROR(ndr, "result", r->out.result);
15720                 ndr->depth--;
15721         }
15722         ndr->depth--;
15723 }
15724
15725 static const struct ndr_interface_call drsuapi_calls[] = {
15726         {
15727                 "drsuapi_DsBind",
15728                 sizeof(struct drsuapi_DsBind),
15729                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsBind,
15730                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsBind,
15731                 (ndr_print_function_t) ndr_print_drsuapi_DsBind,
15732                 false,
15733         },
15734         {
15735                 "drsuapi_DsUnbind",
15736                 sizeof(struct drsuapi_DsUnbind),
15737                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsUnbind,
15738                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsUnbind,
15739                 (ndr_print_function_t) ndr_print_drsuapi_DsUnbind,
15740                 false,
15741         },
15742         {
15743                 "drsuapi_DsReplicaSync",
15744                 sizeof(struct drsuapi_DsReplicaSync),
15745                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaSync,
15746                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaSync,
15747                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaSync,
15748                 false,
15749         },
15750         {
15751                 "drsuapi_DsGetNCChanges",
15752                 sizeof(struct drsuapi_DsGetNCChanges),
15753                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNCChanges,
15754                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNCChanges,
15755                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNCChanges,
15756                 false,
15757         },
15758         {
15759                 "drsuapi_DsReplicaUpdateRefs",
15760                 sizeof(struct drsuapi_DsReplicaUpdateRefs),
15761                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaUpdateRefs,
15762                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaUpdateRefs,
15763                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaUpdateRefs,
15764                 false,
15765         },
15766         {
15767                 "drsuapi_DsReplicaAdd",
15768                 sizeof(struct drsuapi_DsReplicaAdd),
15769                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaAdd,
15770                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaAdd,
15771                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaAdd,
15772                 false,
15773         },
15774         {
15775                 "drsuapi_DsReplicaDel",
15776                 sizeof(struct drsuapi_DsReplicaDel),
15777                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaDel,
15778                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaDel,
15779                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaDel,
15780                 false,
15781         },
15782         {
15783                 "drsuapi_DsReplicaMod",
15784                 sizeof(struct drsuapi_DsReplicaMod),
15785                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaMod,
15786                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaMod,
15787                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaMod,
15788                 false,
15789         },
15790         {
15791                 "DRSUAPI_VERIFY_NAMES",
15792                 sizeof(struct DRSUAPI_VERIFY_NAMES),
15793                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_VERIFY_NAMES,
15794                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_VERIFY_NAMES,
15795                 (ndr_print_function_t) ndr_print_DRSUAPI_VERIFY_NAMES,
15796                 false,
15797         },
15798         {
15799                 "drsuapi_DsGetMemberships",
15800                 sizeof(struct drsuapi_DsGetMemberships),
15801                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships,
15802                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships,
15803                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships,
15804                 false,
15805         },
15806         {
15807                 "DRSUAPI_INTER_DOMAIN_MOVE",
15808                 sizeof(struct DRSUAPI_INTER_DOMAIN_MOVE),
15809                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_INTER_DOMAIN_MOVE,
15810                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE,
15811                 (ndr_print_function_t) ndr_print_DRSUAPI_INTER_DOMAIN_MOVE,
15812                 false,
15813         },
15814         {
15815                 "drsuapi_DsGetNT4ChangeLog",
15816                 sizeof(struct drsuapi_DsGetNT4ChangeLog),
15817                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNT4ChangeLog,
15818                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNT4ChangeLog,
15819                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNT4ChangeLog,
15820                 false,
15821         },
15822         {
15823                 "drsuapi_DsCrackNames",
15824                 sizeof(struct drsuapi_DsCrackNames),
15825                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsCrackNames,
15826                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsCrackNames,
15827                 (ndr_print_function_t) ndr_print_drsuapi_DsCrackNames,
15828                 false,
15829         },
15830         {
15831                 "drsuapi_DsWriteAccountSpn",
15832                 sizeof(struct drsuapi_DsWriteAccountSpn),
15833                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsWriteAccountSpn,
15834                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsWriteAccountSpn,
15835                 (ndr_print_function_t) ndr_print_drsuapi_DsWriteAccountSpn,
15836                 false,
15837         },
15838         {
15839                 "drsuapi_DsRemoveDSServer",
15840                 sizeof(struct drsuapi_DsRemoveDSServer),
15841                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsRemoveDSServer,
15842                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsRemoveDSServer,
15843                 (ndr_print_function_t) ndr_print_drsuapi_DsRemoveDSServer,
15844                 false,
15845         },
15846         {
15847                 "DRSUAPI_REMOVE_DS_DOMAIN",
15848                 sizeof(struct DRSUAPI_REMOVE_DS_DOMAIN),
15849                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REMOVE_DS_DOMAIN,
15850                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN,
15851                 (ndr_print_function_t) ndr_print_DRSUAPI_REMOVE_DS_DOMAIN,
15852                 false,
15853         },
15854         {
15855                 "drsuapi_DsGetDomainControllerInfo",
15856                 sizeof(struct drsuapi_DsGetDomainControllerInfo),
15857                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetDomainControllerInfo,
15858                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetDomainControllerInfo,
15859                 (ndr_print_function_t) ndr_print_drsuapi_DsGetDomainControllerInfo,
15860                 false,
15861         },
15862         {
15863                 "drsuapi_DsAddEntry",
15864                 sizeof(struct drsuapi_DsAddEntry),
15865                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsAddEntry,
15866                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsAddEntry,
15867                 (ndr_print_function_t) ndr_print_drsuapi_DsAddEntry,
15868                 false,
15869         },
15870         {
15871                 "drsuapi_DsExecuteKCC",
15872                 sizeof(struct drsuapi_DsExecuteKCC),
15873                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsExecuteKCC,
15874                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsExecuteKCC,
15875                 (ndr_print_function_t) ndr_print_drsuapi_DsExecuteKCC,
15876                 false,
15877         },
15878         {
15879                 "drsuapi_DsReplicaGetInfo",
15880                 sizeof(struct drsuapi_DsReplicaGetInfo),
15881                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaGetInfo,
15882                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaGetInfo,
15883                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaGetInfo,
15884                 false,
15885         },
15886         {
15887                 "DRSUAPI_ADD_SID_HISTORY",
15888                 sizeof(struct DRSUAPI_ADD_SID_HISTORY),
15889                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_ADD_SID_HISTORY,
15890                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_ADD_SID_HISTORY,
15891                 (ndr_print_function_t) ndr_print_DRSUAPI_ADD_SID_HISTORY,
15892                 false,
15893         },
15894         {
15895                 "drsuapi_DsGetMemberships2",
15896                 sizeof(struct drsuapi_DsGetMemberships2),
15897                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships2,
15898                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships2,
15899                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships2,
15900                 false,
15901         },
15902         {
15903                 "DRSUAPI_REPLICA_VERIFY_OBJECTS",
15904                 sizeof(struct DRSUAPI_REPLICA_VERIFY_OBJECTS),
15905                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15906                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15907                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15908                 false,
15909         },
15910         {
15911                 "DRSUAPI_GET_OBJECT_EXISTENCE",
15912                 sizeof(struct DRSUAPI_GET_OBJECT_EXISTENCE),
15913                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE,
15914                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE,
15915                 (ndr_print_function_t) ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE,
15916                 false,
15917         },
15918         {
15919                 "drsuapi_QuerySitesByCost",
15920                 sizeof(struct drsuapi_QuerySitesByCost),
15921                 (ndr_push_flags_fn_t) ndr_push_drsuapi_QuerySitesByCost,
15922                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_QuerySitesByCost,
15923                 (ndr_print_function_t) ndr_print_drsuapi_QuerySitesByCost,
15924                 false,
15925         },
15926         { NULL, 0, NULL, NULL, NULL, false }
15927 };
15928
15929 static const char * const drsuapi_endpoint_strings[] = {
15930         "ncacn_np:[\\pipe\\lsass]",
15931         "ncacn_np:[\\pipe\\protected_storage]",
15932         "ncacn_ip_tcp:",
15933         "ncalrpc:",
15934 };
15935
15936 static const struct ndr_interface_string_array drsuapi_endpoints = {
15937         .count  = 4,
15938         .names  = drsuapi_endpoint_strings
15939 };
15940
15941 static const char * const drsuapi_authservice_strings[] = {
15942         "ldap",
15943 };
15944
15945 static const struct ndr_interface_string_array drsuapi_authservices = {
15946         .count  = 1,
15947         .names  = drsuapi_authservice_strings
15948 };
15949
15950
15951 const struct ndr_interface_table ndr_table_drsuapi = {
15952         .name           = "drsuapi",
15953         .syntax_id      = {
15954                 {0xe3514235,0x4b06,0x11d1,{0xab,0x04},{0x00,0xc0,0x4f,0xc2,0xdc,0xd2}},
15955                 NDR_DRSUAPI_VERSION
15956         },
15957         .helpstring     = NDR_DRSUAPI_HELPSTRING,
15958         .num_calls      = 25,
15959         .calls          = drsuapi_calls,
15960         .endpoints      = &drsuapi_endpoints,
15961         .authservices   = &drsuapi_authservices
15962 };
15963