librpc/gen_ndr/ndr_drsuapi.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_drsuapi.h"
   5
   6 #include "librpc/gen_ndr/ndr_security.h"
   7 #include "librpc/gen_ndr/ndr_misc.h"
   8 #include "librpc/gen_ndr/ndr_samr.h"
   9 #include "librpc/ndr/ndr_compression.h"
  10 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DrsOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  11 {
  12         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  13         return NDR_ERR_SUCCESS;
  14 }
  15
  16 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DrsOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  17 {
  18         uint32_t v;
  19         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  20         *r = v;
  21         return NDR_ERR_SUCCESS;
  22 }
  23
  24 _PUBLIC_ void ndr_print_drsuapi_DrsOptions(struct ndr_print *ndr, const char *name, uint32_t r)
  25 {
  26         ndr_print_uint32(ndr, name, r);
  27         ndr->depth++;
  28         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_ASYNC_OP", DRSUAPI_DRS_ASYNC_OP, r);
  29         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GETCHG_CHECK", DRSUAPI_DRS_GETCHG_CHECK, r);
  30         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_UPDATE_NOTIFICATION", DRSUAPI_DRS_UPDATE_NOTIFICATION, r);
  31         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_ADD_REF", DRSUAPI_DRS_ADD_REF, r);
  32         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_ALL", DRSUAPI_DRS_SYNC_ALL, r);
  33         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DEL_REF", DRSUAPI_DRS_DEL_REF, r);
  34         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_WRIT_REP", DRSUAPI_DRS_WRIT_REP, r);
  35         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_INIT_SYNC", DRSUAPI_DRS_INIT_SYNC, r);
  36         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_PER_SYNC", DRSUAPI_DRS_PER_SYNC, r);
  37         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_MAIL_REP", DRSUAPI_DRS_MAIL_REP, r);
  38         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_ASYNC_REP", DRSUAPI_DRS_ASYNC_REP, r);
  39         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_IGNORE_ERROR", DRSUAPI_DRS_IGNORE_ERROR, r);
  40         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_TWOWAY_SYNC", DRSUAPI_DRS_TWOWAY_SYNC, r);
  41         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_CRITICAL_ONLY", DRSUAPI_DRS_CRITICAL_ONLY, r);
  42         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_ANC", DRSUAPI_DRS_GET_ANC, r);
  43         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_NC_SIZE", DRSUAPI_DRS_GET_NC_SIZE, r);
  44         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_LOCAL_ONLY", DRSUAPI_DRS_LOCAL_ONLY, r);
  45         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_BYNAME", DRSUAPI_DRS_SYNC_BYNAME, r);
  46         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_REF_OK", DRSUAPI_DRS_REF_OK, r);
  47         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_NOW", DRSUAPI_DRS_FULL_SYNC_NOW, r);
  48         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NO_SOURCE", DRSUAPI_DRS_NO_SOURCE, r);
  49         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS", DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS, r);
  50         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_FULL_SYNC_PACKET", DRSUAPI_DRS_FULL_SYNC_PACKET, r);
  51         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_REQUEUE", DRSUAPI_DRS_SYNC_REQUEUE, r);
  52         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_URGENT", DRSUAPI_DRS_SYNC_URGENT, r);
  53         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_REF_GCSPN", DRSUAPI_DRS_REF_GCSPN, r);
  54         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NO_DISCARD", DRSUAPI_DRS_NO_DISCARD, r);
  55         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NEVER_SYNCED", DRSUAPI_DRS_NEVER_SYNCED, r);
  56         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING", DRSUAPI_DRS_SPECIAL_SECRET_PROCESSING, r);
  57         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_INIT_SYNC_NOW", DRSUAPI_DRS_INIT_SYNC_NOW, r);
  58         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_PREEMPTED", DRSUAPI_DRS_PREEMPTED, r);
  59         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_FORCED", DRSUAPI_DRS_SYNC_FORCED, r);
  60         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DISABLE_AUTO_SYNC", DRSUAPI_DRS_DISABLE_AUTO_SYNC, r);
  61         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_DISABLE_PERIODIC_SYNC", DRSUAPI_DRS_DISABLE_PERIODIC_SYNC, r);
  62         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_USE_COMPRESSION", DRSUAPI_DRS_USE_COMPRESSION, r);
  63         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_NEVER_NOTIFY", DRSUAPI_DRS_NEVER_NOTIFY, r);
  64         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_SYNC_PAS", DRSUAPI_DRS_SYNC_PAS, r);
  65         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DRS_GET_ALL_GROUP_MEMBERSHIP", DRSUAPI_DRS_GET_ALL_GROUP_MEMBERSHIP, r);
  66         ndr->depth--;
  67 }
  68
  69 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
  70 {
  71         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
  72         return NDR_ERR_SUCCESS;
  73 }
  74
  75 static enum ndr_err_code ndr_pull_drsuapi_SupportedExtensions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
  76 {
  77         uint32_t v;
  78         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
  79         *r = v;
  80         return NDR_ERR_SUCCESS;
  81 }
  82
  83 _PUBLIC_ void ndr_print_drsuapi_SupportedExtensions(struct ndr_print *ndr, const char *name, uint32_t r)
  84 {
  85         ndr_print_uint32(ndr, name, r);
  86         ndr->depth++;
  87         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_BASE", DRSUAPI_SUPPORTED_EXTENSION_BASE, r);
  88         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION", DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION, r);
  89         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI", DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI, r);
  90         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2", DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2, r);
  91         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS", DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS, r);
  92         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1, r);
  93         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION", DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION, r);
  94         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_00000080", DRSUAPI_SUPPORTED_EXTENSION_00000080, r);
  95         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE", DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE, r);
  96         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2, r);
  97         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION", DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION, r);
  98         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2, r);
  99         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD", DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD, r);
 100         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND", DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND, r);
 101         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO", DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO, r);
 102         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION", DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION, r);
 103         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01", DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01, r);
 104         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP", DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP, r);
 105         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY", DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY, r);
 106         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3", DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3, r);
 107         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_00100000", DRSUAPI_SUPPORTED_EXTENSION_00100000, r);
 108         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2", DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2, r);
 109         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6, r);
 110         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS", DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS, r);
 111         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8, r);
 112         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5, r);
 113         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6, r);
 114         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3", DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3, r);
 115         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7", DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7, r);
 116         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT", DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT, r);
 117         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS", DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS, r);
 118         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_20000000", DRSUAPI_SUPPORTED_EXTENSION_20000000, r);
 119         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_40000000", DRSUAPI_SUPPORTED_EXTENSION_40000000, r);
 120         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_80000000", DRSUAPI_SUPPORTED_EXTENSION_80000000, r);
 121         ndr->depth--;
 122 }
 123
 124 static enum ndr_err_code ndr_push_drsuapi_SupportedExtensionsExt(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 125 {
 126         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 127         return NDR_ERR_SUCCESS;
 128 }
 129
 130 static enum ndr_err_code ndr_pull_drsuapi_SupportedExtensionsExt(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 131 {
 132         uint32_t v;
 133         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 134         *r = v;
 135         return NDR_ERR_SUCCESS;
 136 }
 137
 138 _PUBLIC_ void ndr_print_drsuapi_SupportedExtensionsExt(struct ndr_print *ndr, const char *name, uint32_t r)
 139 {
 140         ndr_print_uint32(ndr, name, r);
 141         ndr->depth++;
 142         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_ADAM", DRSUAPI_SUPPORTED_EXTENSION_ADAM, r);
 143         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_SUPPORTED_EXTENSION_LH_BETA2", DRSUAPI_SUPPORTED_EXTENSION_LH_BETA2, r);
 144         ndr->depth--;
 145 }
 146
 147 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo24(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo24 *r)
 148 {
 149         if (ndr_flags & NDR_SCALARS) {
 150                 NDR_CHECK(ndr_push_align(ndr, 4));
 151                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 152                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 153                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 154                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 155         }
 156         if (ndr_flags & NDR_BUFFERS) {
 157         }
 158         return NDR_ERR_SUCCESS;
 159 }
 160
 161 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo24(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo24 *r)
 162 {
 163         if (ndr_flags & NDR_SCALARS) {
 164                 NDR_CHECK(ndr_pull_align(ndr, 4));
 165                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 166                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 168                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 169         }
 170         if (ndr_flags & NDR_BUFFERS) {
 171         }
 172         return NDR_ERR_SUCCESS;
 173 }
 174
 175 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo24(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo24 *r)
 176 {
 177         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo24");
 178         ndr->depth++;
 179         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 180         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 181         ndr_print_uint32(ndr, "pid", r->pid);
 182         ndr->depth--;
 183 }
 184
 185 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo28(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo28 *r)
 186 {
 187         if (ndr_flags & NDR_SCALARS) {
 188                 NDR_CHECK(ndr_push_align(ndr, 4));
 189                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 190                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 192                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 193                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 194         }
 195         if (ndr_flags & NDR_BUFFERS) {
 196         }
 197         return NDR_ERR_SUCCESS;
 198 }
 199
 200 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo28(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo28 *r)
 201 {
 202         if (ndr_flags & NDR_SCALARS) {
 203                 NDR_CHECK(ndr_pull_align(ndr, 4));
 204                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 205                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 207                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 208                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 209         }
 210         if (ndr_flags & NDR_BUFFERS) {
 211         }
 212         return NDR_ERR_SUCCESS;
 213 }
 214
 215 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo28(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo28 *r)
 216 {
 217         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo28");
 218         ndr->depth++;
 219         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 220         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 221         ndr_print_uint32(ndr, "pid", r->pid);
 222         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 223         ndr->depth--;
 224 }
 225
 226 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo48(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfo48 *r)
 227 {
 228         if (ndr_flags & NDR_SCALARS) {
 229                 NDR_CHECK(ndr_push_align(ndr, 4));
 230                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, r->supported_extensions));
 231                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
 232                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pid));
 233                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->repl_epoch));
 234                 NDR_CHECK(ndr_push_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, r->supported_extensions_ext));
 235                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 236                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 237         }
 238         if (ndr_flags & NDR_BUFFERS) {
 239         }
 240         return NDR_ERR_SUCCESS;
 241 }
 242
 243 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo48(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfo48 *r)
 244 {
 245         if (ndr_flags & NDR_SCALARS) {
 246                 NDR_CHECK(ndr_pull_align(ndr, 4));
 247                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensions(ndr, NDR_SCALARS, &r->supported_extensions));
 248                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
 249                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pid));
 250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->repl_epoch));
 251                 NDR_CHECK(ndr_pull_drsuapi_SupportedExtensionsExt(ndr, NDR_SCALARS, &r->supported_extensions_ext));
 252                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->config_dn_guid));
 253                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 254         }
 255         if (ndr_flags & NDR_BUFFERS) {
 256         }
 257         return NDR_ERR_SUCCESS;
 258 }
 259
 260 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo48(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfo48 *r)
 261 {
 262         ndr_print_struct(ndr, name, "drsuapi_DsBindInfo48");
 263         ndr->depth++;
 264         ndr_print_drsuapi_SupportedExtensions(ndr, "supported_extensions", r->supported_extensions);
 265         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
 266         ndr_print_uint32(ndr, "pid", r->pid);
 267         ndr_print_uint32(ndr, "repl_epoch", r->repl_epoch);
 268         ndr_print_drsuapi_SupportedExtensionsExt(ndr, "supported_extensions_ext", r->supported_extensions_ext);
 269         ndr_print_GUID(ndr, "config_dn_guid", &r->config_dn_guid);
 270         ndr->depth--;
 271 }
 272
 273 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoFallBack(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoFallBack *r)
 274 {
 275         if (ndr_flags & NDR_SCALARS) {
 276                 NDR_CHECK(ndr_push_align(ndr, 4));
 277                 {
 278                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 279                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 280                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->info));
 281                         ndr->flags = _flags_save_DATA_BLOB;
 282                 }
 283                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 284         }
 285         if (ndr_flags & NDR_BUFFERS) {
 286         }
 287         return NDR_ERR_SUCCESS;
 288 }
 289
 290 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoFallBack(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoFallBack *r)
 291 {
 292         if (ndr_flags & NDR_SCALARS) {
 293                 NDR_CHECK(ndr_pull_align(ndr, 4));
 294                 {
 295                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 296                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 297                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->info));
 298                         ndr->flags = _flags_save_DATA_BLOB;
 299                 }
 300                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 301         }
 302         if (ndr_flags & NDR_BUFFERS) {
 303         }
 304         return NDR_ERR_SUCCESS;
 305 }
 306
 307 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoFallBack(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoFallBack *r)
 308 {
 309         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoFallBack");
 310         ndr->depth++;
 311         ndr_print_DATA_BLOB(ndr, "info", r->info);
 312         ndr->depth--;
 313 }
 314
 315 static enum ndr_err_code ndr_push_drsuapi_DsBindInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsBindInfo *r)
 316 {
 317         if (ndr_flags & NDR_SCALARS) {
 318                 int level = ndr_push_get_switch_value(ndr, r);
 319                 NDR_CHECK(ndr_push_union_align(ndr, 1));
 320                 switch (level) {
 321                         case 24: {
 322                                 {
 323                                         struct ndr_push *_ndr_info24;
 324                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info24, 4, -1));
 325                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 326                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info24, 4, -1));
 327                                 }
 328                         break; }
 329
 330                         case 28: {
 331                                 {
 332                                         struct ndr_push *_ndr_info28;
 333                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info28, 4, -1));
 334                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 335                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info28, 4, -1));
 336                                 }
 337                         break; }
 338
 339                         case 48: {
 340                                 {
 341                                         struct ndr_push *_ndr_info48;
 342                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info48, 4, -1));
 343                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 344                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info48, 4, -1));
 345                                 }
 346                         break; }
 347
 348                         default: {
 349                                 {
 350                                         struct ndr_push *_ndr_FallBack;
 351                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 352                                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 353                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 354                                 }
 355                         break; }
 356
 357                 }
 358         }
 359         if (ndr_flags & NDR_BUFFERS) {
 360                 int level = ndr_push_get_switch_value(ndr, r);
 361                 switch (level) {
 362                         case 24:
 363                         break;
 364
 365                         case 28:
 366                         break;
 367
 368                         case 48:
 369                         break;
 370
 371                         default:
 372                         break;
 373
 374                 }
 375         }
 376         return NDR_ERR_SUCCESS;
 377 }
 378
 379 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsBindInfo *r)
 380 {
 381         int level;
 382         level = ndr_pull_get_switch_value(ndr, r);
 383         if (ndr_flags & NDR_SCALARS) {
 384                 NDR_CHECK(ndr_pull_union_align(ndr, 1));
 385                 switch (level) {
 386                         case 24: {
 387                                 {
 388                                         struct ndr_pull *_ndr_info24;
 389                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info24, 4, -1));
 390                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
 391                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info24, 4, -1));
 392                                 }
 393                         break; }
 394
 395                         case 28: {
 396                                 {
 397                                         struct ndr_pull *_ndr_info28;
 398                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info28, 4, -1));
 399                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
 400                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info28, 4, -1));
 401                                 }
 402                         break; }
 403
 404                         case 48: {
 405                                 {
 406                                         struct ndr_pull *_ndr_info48;
 407                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info48, 4, -1));
 408                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
 409                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info48, 4, -1));
 410                                 }
 411                         break; }
 412
 413                         default: {
 414                                 {
 415                                         struct ndr_pull *_ndr_FallBack;
 416                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_FallBack, 4, -1));
 417                                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoFallBack(_ndr_FallBack, NDR_SCALARS, &r->FallBack));
 418                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_FallBack, 4, -1));
 419                                 }
 420                         break; }
 421
 422                 }
 423         }
 424         if (ndr_flags & NDR_BUFFERS) {
 425                 switch (level) {
 426                         case 24:
 427                         break;
 428
 429                         case 28:
 430                         break;
 431
 432                         case 48:
 433                         break;
 434
 435                         default:
 436                         break;
 437
 438                 }
 439         }
 440         return NDR_ERR_SUCCESS;
 441 }
 442
 443 _PUBLIC_ void ndr_print_drsuapi_DsBindInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsBindInfo *r)
 444 {
 445         int level;
 446         level = ndr_print_get_switch_value(ndr, r);
 447         ndr_print_union(ndr, name, level, "drsuapi_DsBindInfo");
 448         switch (level) {
 449                 case 24:
 450                         ndr_print_drsuapi_DsBindInfo24(ndr, "info24", &r->info24);
 451                 break;
 452
 453                 case 28:
 454                         ndr_print_drsuapi_DsBindInfo28(ndr, "info28", &r->info28);
 455                 break;
 456
 457                 case 48:
 458                         ndr_print_drsuapi_DsBindInfo48(ndr, "info48", &r->info48);
 459                 break;
 460
 461                 default:
 462                         ndr_print_drsuapi_DsBindInfoFallBack(ndr, "FallBack", &r->FallBack);
 463                 break;
 464
 465         }
 466 }
 467
 468 static enum ndr_err_code ndr_push_drsuapi_DsBindInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsBindInfoCtr *r)
 469 {
 470         if (ndr_flags & NDR_SCALARS) {
 471                 NDR_CHECK(ndr_push_align(ndr, 4));
 472                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
 473                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->length));
 474                 NDR_CHECK(ndr_push_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 475                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 476         }
 477         if (ndr_flags & NDR_BUFFERS) {
 478         }
 479         return NDR_ERR_SUCCESS;
 480 }
 481
 482 static enum ndr_err_code ndr_pull_drsuapi_DsBindInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsBindInfoCtr *r)
 483 {
 484         if (ndr_flags & NDR_SCALARS) {
 485                 NDR_CHECK(ndr_pull_align(ndr, 4));
 486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
 487                 if (r->length < 1 || r->length > 10000) {
 488                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 489                 }
 490                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->length));
 491                 NDR_CHECK(ndr_pull_drsuapi_DsBindInfo(ndr, NDR_SCALARS, &r->info));
 492                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 493         }
 494         if (ndr_flags & NDR_BUFFERS) {
 495         }
 496         return NDR_ERR_SUCCESS;
 497 }
 498
 499 _PUBLIC_ void ndr_print_drsuapi_DsBindInfoCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsBindInfoCtr *r)
 500 {
 501         ndr_print_struct(ndr, name, "drsuapi_DsBindInfoCtr");
 502         ndr->depth++;
 503         ndr_print_uint32(ndr, "length", r->length);
 504         ndr_print_set_switch_value(ndr, &r->info, r->length);
 505         ndr_print_drsuapi_DsBindInfo(ndr, "info", &r->info);
 506         ndr->depth--;
 507 }
 508
 509 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier *r)
 510 {
 511         if (ndr_flags & NDR_SCALARS) {
 512                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, strlen_m(r->dn) + 1));
 513                 NDR_CHECK(ndr_push_align(ndr, 4));
 514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier(r, ndr->iconv_convenience, ndr->flags) - 4));
 515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
 516                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
 517                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
 518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
 519                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
 520                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
 521         }
 522         if (ndr_flags & NDR_BUFFERS) {
 523                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
 524         }
 525         return NDR_ERR_SUCCESS;
 526 }
 527
 528 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier *r)
 529 {
 530         if (ndr_flags & NDR_SCALARS) {
 531                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dn));
 532                 NDR_CHECK(ndr_pull_align(ndr, 4));
 533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
 534                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
 535                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
 536                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
 537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
 538                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, ndr_get_array_size(ndr, &r->dn), sizeof(uint16_t), CH_UTF16));
 539                 if (r->dn) {
 540                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->dn, r->__ndr_size_dn + 1));
 541                 }
 542                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
 543         }
 544         if (ndr_flags & NDR_BUFFERS) {
 545                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
 546         }
 547         return NDR_ERR_SUCCESS;
 548 }
 549
 550 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier *r)
 551 {
 552         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier");
 553         ndr->depth++;
 554         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);
 555         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);
 556         ndr_print_GUID(ndr, "guid", &r->guid);
 557         ndr_print_dom_sid28(ndr, "sid", &r->sid);
 558         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
 559         ndr_print_string(ndr, "dn", r->dn);
 560         ndr->depth--;
 561 }
 562
 563 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier(const struct drsuapi_DsReplicaObjectIdentifier *r, struct smb_iconv_convenience *ic, int flags)
 564 {
 565         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier, ic);
 566 }
 567
 568 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 569 {
 570         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 571         return NDR_ERR_SUCCESS;
 572 }
 573
 574 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 575 {
 576         uint32_t v;
 577         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 578         *r = v;
 579         return NDR_ERR_SUCCESS;
 580 }
 581
 582 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncOptions(struct ndr_print *ndr, const char *name, uint32_t r)
 583 {
 584         ndr_print_uint32(ndr, name, r);
 585         ndr->depth++;
 586         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_OPERATION, r);
 587         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_WRITEABLE", DRSUAPI_DS_REPLICA_SYNC_WRITEABLE, r);
 588         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PERIODIC", DRSUAPI_DS_REPLICA_SYNC_PERIODIC, r);
 589         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING", DRSUAPI_DS_REPLICA_SYNC_INTERSITE_MESSAGING, r);
 590         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES", DRSUAPI_DS_REPLICA_SYNC_ALL_SOURCES, r);
 591         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL", DRSUAPI_DS_REPLICA_SYNC_FULL, r);
 592         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_URGENT", DRSUAPI_DS_REPLICA_SYNC_URGENT, r);
 593         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD", DRSUAPI_DS_REPLICA_SYNC_NO_DISCARD, r);
 594         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FORCE", DRSUAPI_DS_REPLICA_SYNC_FORCE, r);
 595         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE", DRSUAPI_DS_REPLICA_SYNC_ADD_REFERENCE, r);
 596         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED", DRSUAPI_DS_REPLICA_SYNC_NEVER_COMPLETED, r);
 597         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_TWO_WAY", DRSUAPI_DS_REPLICA_SYNC_TWO_WAY, r);
 598         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY", DRSUAPI_DS_REPLICA_SYNC_NEVER_NOTIFY, r);
 599         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL", DRSUAPI_DS_REPLICA_SYNC_INITIAL, r);
 600         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION", DRSUAPI_DS_REPLICA_SYNC_USE_COMPRESSION, r);
 601         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ABANDONED", DRSUAPI_DS_REPLICA_SYNC_ABANDONED, r);
 602         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_INITIAL_IN_PROGRESS, r);
 603         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET", DRSUAPI_DS_REPLICA_SYNC_PARTIAL_ATTRIBUTE_SET, r);
 604         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_REQUEUE", DRSUAPI_DS_REPLICA_SYNC_REQUEUE, r);
 605         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION", DRSUAPI_DS_REPLICA_SYNC_NOTIFICATION, r);
 606         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA", DRSUAPI_DS_REPLICA_SYNC_ASYNCHRONOUS_REPLICA, r);
 607         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_CRITICAL", DRSUAPI_DS_REPLICA_SYNC_CRITICAL, r);
 608         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS", DRSUAPI_DS_REPLICA_SYNC_FULL_IN_PROGRESS, r);
 609         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_SYNC_PREEMPTED", DRSUAPI_DS_REPLICA_SYNC_PREEMPTED, r);
 610         ndr->depth--;
 611 }
 612
 613 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaSyncRequest1 *r)
 614 {
 615         if (ndr_flags & NDR_SCALARS) {
 616                 NDR_CHECK(ndr_push_align(ndr, 5));
 617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
 618                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 619                 {
 620                         uint32_t _flags_save_string = ndr->flags;
 621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 622                         NDR_CHECK(ndr_push_unique_ptr(ndr, r->other_info));
 623                         ndr->flags = _flags_save_string;
 624                 }
 625                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
 626                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
 627         }
 628         if (ndr_flags & NDR_BUFFERS) {
 629                 if (r->naming_context) {
 630                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 631                 }
 632                 {
 633                         uint32_t _flags_save_string = ndr->flags;
 634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 635                         if (r->other_info) {
 636                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->other_info));
 637                         }
 638                         ndr->flags = _flags_save_string;
 639                 }
 640         }
 641         return NDR_ERR_SUCCESS;
 642 }
 643
 644 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaSyncRequest1 *r)
 645 {
 646         uint32_t _ptr_naming_context;
 647         TALLOC_CTX *_mem_save_naming_context_0;
 648         uint32_t _ptr_other_info;
 649         TALLOC_CTX *_mem_save_other_info_0;
 650         if (ndr_flags & NDR_SCALARS) {
 651                 NDR_CHECK(ndr_pull_align(ndr, 5));
 652                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
 653                 if (_ptr_naming_context) {
 654                         NDR_PULL_ALLOC(ndr, r->naming_context);
 655                 } else {
 656                         r->naming_context = NULL;
 657                 }
 658                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
 659                 {
 660                         uint32_t _flags_save_string = ndr->flags;
 661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 662                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_other_info));
 663                         if (_ptr_other_info) {
 664                                 NDR_PULL_ALLOC(ndr, r->other_info);
 665                         } else {
 666                                 r->other_info = NULL;
 667                         }
 668                         ndr->flags = _flags_save_string;
 669                 }
 670                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
 671                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
 672         }
 673         if (ndr_flags & NDR_BUFFERS) {
 674                 if (r->naming_context) {
 675                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
 676                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
 677                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
 678                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
 679                 }
 680                 {
 681                         uint32_t _flags_save_string = ndr->flags;
 682                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
 683                         if (r->other_info) {
 684                                 _mem_save_other_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 685                                 NDR_PULL_SET_MEM_CTX(ndr, r->other_info, 0);
 686                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->other_info));
 687                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_other_info_0, 0);
 688                         }
 689                         ndr->flags = _flags_save_string;
 690                 }
 691         }
 692         return NDR_ERR_SUCCESS;
 693 }
 694
 695 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaSyncRequest1 *r)
 696 {
 697         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSyncRequest1");
 698         ndr->depth++;
 699         ndr_print_ptr(ndr, "naming_context", r->naming_context);
 700         ndr->depth++;
 701         if (r->naming_context) {
 702                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
 703         }
 704         ndr->depth--;
 705         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
 706         ndr_print_ptr(ndr, "other_info", r->other_info);
 707         ndr->depth++;
 708         if (r->other_info) {
 709                 ndr_print_string(ndr, "other_info", r->other_info);
 710         }
 711         ndr->depth--;
 712         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
 713         ndr->depth--;
 714 }
 715
 716 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSyncRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaSyncRequest *r)
 717 {
 718         if (ndr_flags & NDR_SCALARS) {
 719                 int level = ndr_push_get_switch_value(ndr, r);
 720                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
 721                 NDR_CHECK(ndr_push_union_align(ndr, 5));
 722                 switch (level) {
 723                         case 1: {
 724                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 725                         break; }
 726
 727                         default:
 728                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 729                 }
 730         }
 731         if (ndr_flags & NDR_BUFFERS) {
 732                 int level = ndr_push_get_switch_value(ndr, r);
 733                 switch (level) {
 734                         case 1:
 735                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 736                         break;
 737
 738                         default:
 739                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 740                 }
 741         }
 742         return NDR_ERR_SUCCESS;
 743 }
 744
 745 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSyncRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaSyncRequest *r)
 746 {
 747         int level;
 748         int32_t _level;
 749         level = ndr_pull_get_switch_value(ndr, r);
 750         if (ndr_flags & NDR_SCALARS) {
 751                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
 752                 if (_level != level) {
 753                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
 754                 }
 755                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
 756                 switch (level) {
 757                         case 1: {
 758                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_SCALARS, &r->req1));
 759                         break; }
 760
 761                         default:
 762                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 763                 }
 764         }
 765         if (ndr_flags & NDR_BUFFERS) {
 766                 switch (level) {
 767                         case 1:
 768                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest1(ndr, NDR_BUFFERS, &r->req1));
 769                         break;
 770
 771                         default:
 772                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
 773                 }
 774         }
 775         return NDR_ERR_SUCCESS;
 776 }
 777
 778 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSyncRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaSyncRequest *r)
 779 {
 780         int level;
 781         level = ndr_print_get_switch_value(ndr, r);
 782         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaSyncRequest");
 783         switch (level) {
 784                 case 1:
 785                         ndr_print_drsuapi_DsReplicaSyncRequest1(ndr, "req1", &r->req1);
 786                 break;
 787
 788                 default:
 789                         ndr_print_bad_level(ndr, name, level);
 790         }
 791 }
 792
 793 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaHighWaterMark(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaHighWaterMark *r)
 794 {
 795         if (ndr_flags & NDR_SCALARS) {
 796                 NDR_CHECK(ndr_push_align(ndr, 8));
 797                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
 798                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->reserved_usn));
 799                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 800                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 801         }
 802         if (ndr_flags & NDR_BUFFERS) {
 803         }
 804         return NDR_ERR_SUCCESS;
 805 }
 806
 807 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaHighWaterMark(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaHighWaterMark *r)
 808 {
 809         if (ndr_flags & NDR_SCALARS) {
 810                 NDR_CHECK(ndr_pull_align(ndr, 8));
 811                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
 812                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->reserved_usn));
 813                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 814                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 815         }
 816         if (ndr_flags & NDR_BUFFERS) {
 817         }
 818         return NDR_ERR_SUCCESS;
 819 }
 820
 821 _PUBLIC_ void ndr_print_drsuapi_DsReplicaHighWaterMark(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaHighWaterMark *r)
 822 {
 823         ndr_print_struct(ndr, name, "drsuapi_DsReplicaHighWaterMark");
 824         ndr->depth++;
 825         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
 826         ndr_print_hyper(ndr, "reserved_usn", r->reserved_usn);
 827         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 828         ndr->depth--;
 829 }
 830
 831 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor *r)
 832 {
 833         if (ndr_flags & NDR_SCALARS) {
 834                 NDR_CHECK(ndr_push_align(ndr, 8));
 835                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 836                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
 837                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 838         }
 839         if (ndr_flags & NDR_BUFFERS) {
 840         }
 841         return NDR_ERR_SUCCESS;
 842 }
 843
 844 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor *r)
 845 {
 846         if (ndr_flags & NDR_SCALARS) {
 847                 NDR_CHECK(ndr_pull_align(ndr, 8));
 848                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
 849                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
 850                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 851         }
 852         if (ndr_flags & NDR_BUFFERS) {
 853         }
 854         return NDR_ERR_SUCCESS;
 855 }
 856
 857 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor *r)
 858 {
 859         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor");
 860         ndr->depth++;
 861         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
 862         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
 863         ndr->depth--;
 864 }
 865
 866 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtrEx *r)
 867 {
 868         uint32_t cntr_cursors_0;
 869         if (ndr_flags & NDR_SCALARS) {
 870                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
 871                 NDR_CHECK(ndr_push_align(ndr, 8));
 872                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
 873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
 875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
 876                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 877                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 878                 }
 879                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 880         }
 881         if (ndr_flags & NDR_BUFFERS) {
 882         }
 883         return NDR_ERR_SUCCESS;
 884 }
 885
 886 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtrEx *r)
 887 {
 888         uint32_t cntr_cursors_0;
 889         TALLOC_CTX *_mem_save_cursors_0;
 890         if (ndr_flags & NDR_SCALARS) {
 891                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
 892                 NDR_CHECK(ndr_pull_align(ndr, 8));
 893                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 895                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
 896                 if (r->count > 0x100000) {
 897                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
 898                 }
 899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 900                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
 901                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
 902                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
 903                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
 904                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
 905                 }
 906                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
 907                 if (r->cursors) {
 908                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
 909                 }
 910                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
 911         }
 912         if (ndr_flags & NDR_BUFFERS) {
 913         }
 914         return NDR_ERR_SUCCESS;
 915 }
 916
 917 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtrEx *r)
 918 {
 919         uint32_t cntr_cursors_0;
 920         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtrEx");
 921         ndr->depth++;
 922         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
 923         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
 924         ndr_print_uint32(ndr, "count", r->count);
 925         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
 926         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
 927         ndr->depth++;
 928         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
 929                 char *idx_0=NULL;
 930                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
 931                         ndr_print_drsuapi_DsReplicaCursor(ndr, "cursors", &r->cursors[cntr_cursors_0]);
 932                         free(idx_0);
 933                 }
 934         }
 935         ndr->depth--;
 936         ndr->depth--;
 937 }
 938
 939 static enum ndr_err_code ndr_push_drsuapi_DsExtendedOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation r)
 940 {
 941         {
 942                 uint32_t _flags_save_ENUM = ndr->flags;
 943                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 944                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 945                 ndr->flags = _flags_save_ENUM;
 946         }
 947         return NDR_ERR_SUCCESS;
 948 }
 949
 950 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedOperation *r)
 951 {
 952         uint32_t v;
 953         {
 954                 uint32_t _flags_save_ENUM = ndr->flags;
 955                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 956                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
 957                 *r = v;
 958                 ndr->flags = _flags_save_ENUM;
 959         }
 960         return NDR_ERR_SUCCESS;
 961 }
 962
 963 _PUBLIC_ void ndr_print_drsuapi_DsExtendedOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedOperation r)
 964 {
 965         const char *val = NULL;
 966
 967         {
 968                 uint32_t _flags_save_ENUM = ndr->flags;
 969                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 970                 switch (r) {
 971                         case DRSUAPI_EXOP_NONE: val = "DRSUAPI_EXOP_NONE"; break;
 972                         case DRSUAPI_EXOP_FSMO_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_REQ_ROLE"; break;
 973                         case DRSUAPI_EXOP_FSMO_RID_ALLOC: val = "DRSUAPI_EXOP_FSMO_RID_ALLOC"; break;
 974                         case DRSUAPI_EXOP_FSMO_RID_REQ_ROLE: val = "DRSUAPI_EXOP_FSMO_RID_REQ_ROLE"; break;
 975                         case DRSUAPI_EXOP_FSMO_REQ_PDC: val = "DRSUAPI_EXOP_FSMO_REQ_PDC"; break;
 976                         case DRSUAPI_EXOP_FSMO_ABANDON_ROLE: val = "DRSUAPI_EXOP_FSMO_ABANDON_ROLE"; break;
 977                         case DRSUAPI_EXOP_REPL_OBJ: val = "DRSUAPI_EXOP_REPL_OBJ"; break;
 978                         case DRSUAPI_EXOP_REPL_SECRET: val = "DRSUAPI_EXOP_REPL_SECRET"; break;
 979                 }
 980                 ndr_print_enum(ndr, name, "ENUM", val, r);
 981                 ndr->flags = _flags_save_ENUM;
 982         }
 983 }
 984
 985 static enum ndr_err_code ndr_push_drsuapi_DsExtendedError(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsExtendedError r)
 986 {
 987         {
 988                 uint32_t _flags_save_ENUM = ndr->flags;
 989                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
 990                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
 991                 ndr->flags = _flags_save_ENUM;
 992         }
 993         return NDR_ERR_SUCCESS;
 994 }
 995
 996 static enum ndr_err_code ndr_pull_drsuapi_DsExtendedError(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsExtendedError *r)
 997 {
 998         uint32_t v;
 999         {
1000                 uint32_t _flags_save_ENUM = ndr->flags;
1001                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1002                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1003                 *r = v;
1004                 ndr->flags = _flags_save_ENUM;
1005         }
1006         return NDR_ERR_SUCCESS;
1007 }
1008
1009 _PUBLIC_ void ndr_print_drsuapi_DsExtendedError(struct ndr_print *ndr, const char *name, enum drsuapi_DsExtendedError r)
1010 {
1011         const char *val = NULL;
1012
1013         {
1014                 uint32_t _flags_save_ENUM = ndr->flags;
1015                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1016                 switch (r) {
1017                         case DRSUAPI_EXOP_ERR_NONE: val = "DRSUAPI_EXOP_ERR_NONE"; break;
1018                         case DRSUAPI_EXOP_ERR_SUCCESS: val = "DRSUAPI_EXOP_ERR_SUCCESS"; break;
1019                         case DRSUAPI_EXOP_ERR_UNKNOWN_OP: val = "DRSUAPI_EXOP_ERR_UNKNOWN_OP"; break;
1020                         case DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER: val = "DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER"; break;
1021                         case DRSUAPI_EXOP_ERR_UPDATE_ERR: val = "DRSUAPI_EXOP_ERR_UPDATE_ERR"; break;
1022                         case DRSUAPI_EXOP_ERR_EXCEPTION: val = "DRSUAPI_EXOP_ERR_EXCEPTION"; break;
1023                         case DRSUAPI_EXOP_ERR_UNKNOWN_CALLER: val = "DRSUAPI_EXOP_ERR_UNKNOWN_CALLER"; break;
1024                         case DRSUAPI_EXOP_ERR_RID_ALLOC: val = "DRSUAPI_EXOP_ERR_RID_ALLOC"; break;
1025                         case DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED: val = "DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED"; break;
1026                         case DRSUAPI_EXOP_ERR_FMSO_PENDING_OP: val = "DRSUAPI_EXOP_ERR_FMSO_PENDING_OP"; break;
1027                         case DRSUAPI_EXOP_ERR_MISMATCH: val = "DRSUAPI_EXOP_ERR_MISMATCH"; break;
1028                         case DRSUAPI_EXOP_ERR_COULDNT_CONTACT: val = "DRSUAPI_EXOP_ERR_COULDNT_CONTACT"; break;
1029                         case DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES: val = "DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES"; break;
1030                         case DRSUAPI_EXOP_ERR_DIR_ERROR: val = "DRSUAPI_EXOP_ERR_DIR_ERROR"; break;
1031                         case DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS: val = "DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS"; break;
1032                         case DRSUAPI_EXOP_ERR_ACCESS_DENIED: val = "DRSUAPI_EXOP_ERR_ACCESS_DENIED"; break;
1033                         case DRSUAPI_EXOP_ERR_PARAM_ERROR: val = "DRSUAPI_EXOP_ERR_PARAM_ERROR"; break;
1034                 }
1035                 ndr_print_enum(ndr, name, "ENUM", val, r);
1036                 ndr->flags = _flags_save_ENUM;
1037         }
1038 }
1039
1040 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest5(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest5 *r)
1041 {
1042         if (ndr_flags & NDR_SCALARS) {
1043                 NDR_CHECK(ndr_push_align(ndr, 8));
1044                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1045                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1046                 if (r->naming_context == NULL) {
1047                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1048                 }
1049                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1050                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1051                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1052                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
1053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1055                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1056                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1057                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1058         }
1059         if (ndr_flags & NDR_BUFFERS) {
1060                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1061                 if (r->uptodateness_vector) {
1062                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1063                 }
1064         }
1065         return NDR_ERR_SUCCESS;
1066 }
1067
1068 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest5(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest5 *r)
1069 {
1070         uint32_t _ptr_naming_context;
1071         TALLOC_CTX *_mem_save_naming_context_0;
1072         uint32_t _ptr_uptodateness_vector;
1073         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1074         if (ndr_flags & NDR_SCALARS) {
1075                 NDR_CHECK(ndr_pull_align(ndr, 8));
1076                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1077                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1078                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1079                 if (_ptr_naming_context) {
1080                         NDR_PULL_ALLOC(ndr, r->naming_context);
1081                 } else {
1082                         r->naming_context = NULL;
1083                 }
1084                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1085                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1086                 if (_ptr_uptodateness_vector) {
1087                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1088                 } else {
1089                         r->uptodateness_vector = NULL;
1090                 }
1091                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
1092                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1094                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1095                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1096                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1097         }
1098         if (ndr_flags & NDR_BUFFERS) {
1099                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1100                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1101                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1102                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1103                 if (r->uptodateness_vector) {
1104                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1105                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1106                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1107                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1108                 }
1109         }
1110         return NDR_ERR_SUCCESS;
1111 }
1112
1113 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest5(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest5 *r)
1114 {
1115         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest5");
1116         ndr->depth++;
1117         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1118         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1119         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1120         ndr->depth++;
1121         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1122         ndr->depth--;
1123         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1124         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1125         ndr->depth++;
1126         if (r->uptodateness_vector) {
1127                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1128         }
1129         ndr->depth--;
1130         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
1131         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1132         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1133         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1134         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1135         ndr->depth--;
1136 }
1137
1138 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOID(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOID *r)
1139 {
1140         if (ndr_flags & NDR_SCALARS) {
1141                 NDR_CHECK(ndr_push_align(ndr, 5));
1142                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
1143                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary_oid));
1144                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1145         }
1146         if (ndr_flags & NDR_BUFFERS) {
1147                 if (r->binary_oid) {
1148                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
1149                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->binary_oid, r->length));
1150                 }
1151         }
1152         return NDR_ERR_SUCCESS;
1153 }
1154
1155 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOID(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOID *r)
1156 {
1157         uint32_t _ptr_binary_oid;
1158         TALLOC_CTX *_mem_save_binary_oid_0;
1159         if (ndr_flags & NDR_SCALARS) {
1160                 NDR_CHECK(ndr_pull_align(ndr, 5));
1161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
1162                 if (r->length > 10000) {
1163                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1164                 }
1165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary_oid));
1166                 if (_ptr_binary_oid) {
1167                         NDR_PULL_ALLOC(ndr, r->binary_oid);
1168                 } else {
1169                         r->binary_oid = NULL;
1170                 }
1171                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1172         }
1173         if (ndr_flags & NDR_BUFFERS) {
1174                 if (r->binary_oid) {
1175                         _mem_save_binary_oid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1176                         NDR_PULL_SET_MEM_CTX(ndr, r->binary_oid, 0);
1177                         NDR_CHECK(ndr_pull_array_size(ndr, &r->binary_oid));
1178                         NDR_PULL_ALLOC_N(ndr, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid));
1179                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->binary_oid, ndr_get_array_size(ndr, &r->binary_oid)));
1180                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_oid_0, 0);
1181                 }
1182                 if (r->binary_oid) {
1183                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->binary_oid, r->length));
1184                 }
1185         }
1186         return NDR_ERR_SUCCESS;
1187 }
1188
1189 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping *r)
1190 {
1191         if (ndr_flags & NDR_SCALARS) {
1192                 NDR_CHECK(ndr_push_align(ndr, 5));
1193                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->id_prefix));
1194                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1195                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1196         }
1197         if (ndr_flags & NDR_BUFFERS) {
1198                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1199         }
1200         return NDR_ERR_SUCCESS;
1201 }
1202
1203 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping *r)
1204 {
1205         if (ndr_flags & NDR_SCALARS) {
1206                 NDR_CHECK(ndr_pull_align(ndr, 5));
1207                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->id_prefix));
1208                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_SCALARS, &r->oid));
1209                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1210         }
1211         if (ndr_flags & NDR_BUFFERS) {
1212                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOID(ndr, NDR_BUFFERS, &r->oid));
1213         }
1214         return NDR_ERR_SUCCESS;
1215 }
1216
1217 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping *r)
1218 {
1219         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping");
1220         ndr->depth++;
1221         ndr_print_uint32(ndr, "id_prefix", r->id_prefix);
1222         ndr_print_drsuapi_DsReplicaOID(ndr, "oid", &r->oid);
1223         ndr->depth--;
1224 }
1225
1226 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1227 {
1228         uint32_t cntr_mappings_1;
1229         if (ndr_flags & NDR_SCALARS) {
1230                 NDR_CHECK(ndr_push_align(ndr, 5));
1231                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_mappings));
1232                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mappings));
1233                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1234         }
1235         if (ndr_flags & NDR_BUFFERS) {
1236                 if (r->mappings) {
1237                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_mappings));
1238                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1239                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1240                         }
1241                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1242                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1243                         }
1244                 }
1245         }
1246         return NDR_ERR_SUCCESS;
1247 }
1248
1249 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1250 {
1251         uint32_t _ptr_mappings;
1252         uint32_t cntr_mappings_1;
1253         TALLOC_CTX *_mem_save_mappings_0;
1254         TALLOC_CTX *_mem_save_mappings_1;
1255         if (ndr_flags & NDR_SCALARS) {
1256                 NDR_CHECK(ndr_pull_align(ndr, 5));
1257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_mappings));
1258                 if (r->num_mappings > 0x100000) {
1259                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1260                 }
1261                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mappings));
1262                 if (_ptr_mappings) {
1263                         NDR_PULL_ALLOC(ndr, r->mappings);
1264                 } else {
1265                         r->mappings = NULL;
1266                 }
1267                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
1268         }
1269         if (ndr_flags & NDR_BUFFERS) {
1270                 if (r->mappings) {
1271                         _mem_save_mappings_0 = NDR_PULL_GET_MEM_CTX(ndr);
1272                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1273                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mappings));
1274                         NDR_PULL_ALLOC_N(ndr, r->mappings, ndr_get_array_size(ndr, &r->mappings));
1275                         _mem_save_mappings_1 = NDR_PULL_GET_MEM_CTX(ndr);
1276                         NDR_PULL_SET_MEM_CTX(ndr, r->mappings, 0);
1277                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1278                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_SCALARS, &r->mappings[cntr_mappings_1]));
1279                         }
1280                         for (cntr_mappings_1 = 0; cntr_mappings_1 < r->num_mappings; cntr_mappings_1++) {
1281                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping(ndr, NDR_BUFFERS, &r->mappings[cntr_mappings_1]));
1282                         }
1283                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_1, 0);
1284                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mappings_0, 0);
1285                 }
1286                 if (r->mappings) {
1287                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->mappings, r->num_mappings));
1288                 }
1289         }
1290         return NDR_ERR_SUCCESS;
1291 }
1292
1293 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOIDMapping_Ctr *r)
1294 {
1295         uint32_t cntr_mappings_1;
1296         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOIDMapping_Ctr");
1297         ndr->depth++;
1298         ndr_print_uint32(ndr, "num_mappings", r->num_mappings);
1299         ndr_print_ptr(ndr, "mappings", r->mappings);
1300         ndr->depth++;
1301         if (r->mappings) {
1302                 ndr->print(ndr, "%s: ARRAY(%d)", "mappings", (int)r->num_mappings);
1303                 ndr->depth++;
1304                 for (cntr_mappings_1=0;cntr_mappings_1<r->num_mappings;cntr_mappings_1++) {
1305                         char *idx_1=NULL;
1306                         if (asprintf(&idx_1, "[%d]", cntr_mappings_1) != -1) {
1307                                 ndr_print_drsuapi_DsReplicaOIDMapping(ndr, "mappings", &r->mappings[cntr_mappings_1]);
1308                                 free(idx_1);
1309                         }
1310                 }
1311                 ndr->depth--;
1312         }
1313         ndr->depth--;
1314         ndr->depth--;
1315 }
1316
1317 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAttributeId(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsAttributeId r)
1318 {
1319         {
1320                 uint32_t _flags_save_ENUM = ndr->flags;
1321                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1322                 NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
1323                 ndr->flags = _flags_save_ENUM;
1324         }
1325         return NDR_ERR_SUCCESS;
1326 }
1327
1328 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAttributeId(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsAttributeId *r)
1329 {
1330         uint32_t v;
1331         {
1332                 uint32_t _flags_save_ENUM = ndr->flags;
1333                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1334                 NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
1335                 *r = v;
1336                 ndr->flags = _flags_save_ENUM;
1337         }
1338         return NDR_ERR_SUCCESS;
1339 }
1340
1341 _PUBLIC_ void ndr_print_drsuapi_DsAttributeId(struct ndr_print *ndr, const char *name, enum drsuapi_DsAttributeId r)
1342 {
1343         const char *val = NULL;
1344
1345         {
1346                 uint32_t _flags_save_ENUM = ndr->flags;
1347                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
1348                 switch (r) {
1349                         case DRSUAPI_ATTRIBUTE_objectClass: val = "DRSUAPI_ATTRIBUTE_objectClass"; break;
1350                         case DRSUAPI_ATTRIBUTE_cn: val = "DRSUAPI_ATTRIBUTE_cn"; break;
1351                         case DRSUAPI_ATTRIBUTE_description: val = "DRSUAPI_ATTRIBUTE_description"; break;
1352                         case DRSUAPI_ATTRIBUTE_member: val = "DRSUAPI_ATTRIBUTE_member"; break;
1353                         case DRSUAPI_ATTRIBUTE_instanceType: val = "DRSUAPI_ATTRIBUTE_instanceType"; break;
1354                         case DRSUAPI_ATTRIBUTE_whenCreated: val = "DRSUAPI_ATTRIBUTE_whenCreated"; break;
1355                         case DRSUAPI_ATTRIBUTE_possSuperiors: val = "DRSUAPI_ATTRIBUTE_possSuperiors"; break;
1356                         case DRSUAPI_ATTRIBUTE_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_hasMasterNCs"; break;
1357                         case DRSUAPI_ATTRIBUTE_subClassOf: val = "DRSUAPI_ATTRIBUTE_subClassOf"; break;
1358                         case DRSUAPI_ATTRIBUTE_governsID: val = "DRSUAPI_ATTRIBUTE_governsID"; break;
1359                         case DRSUAPI_ATTRIBUTE_mustContain: val = "DRSUAPI_ATTRIBUTE_mustContain"; break;
1360                         case DRSUAPI_ATTRIBUTE_mayContain: val = "DRSUAPI_ATTRIBUTE_mayContain"; break;
1361                         case DRSUAPI_ATTRIBUTE_rDNAttId: val = "DRSUAPI_ATTRIBUTE_rDNAttId"; break;
1362                         case DRSUAPI_ATTRIBUTE_attributeID: val = "DRSUAPI_ATTRIBUTE_attributeID"; break;
1363                         case DRSUAPI_ATTRIBUTE_attributeSyntax: val = "DRSUAPI_ATTRIBUTE_attributeSyntax"; break;
1364                         case DRSUAPI_ATTRIBUTE_isSingleValued: val = "DRSUAPI_ATTRIBUTE_isSingleValued"; break;
1365                         case DRSUAPI_ATTRIBUTE_rangeLower: val = "DRSUAPI_ATTRIBUTE_rangeLower"; break;
1366                         case DRSUAPI_ATTRIBUTE_rangeUpper: val = "DRSUAPI_ATTRIBUTE_rangeUpper"; break;
1367                         case DRSUAPI_ATTRIBUTE_dMDLocation: val = "DRSUAPI_ATTRIBUTE_dMDLocation"; break;
1368                         case DRSUAPI_ATTRIBUTE_objectVersion: val = "DRSUAPI_ATTRIBUTE_objectVersion"; break;
1369                         case DRSUAPI_ATTRIBUTE_invocationId: val = "DRSUAPI_ATTRIBUTE_invocationId"; break;
1370                         case DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly: val = "DRSUAPI_ATTRIBUTE_showInAdvancedViewOnly"; break;
1371                         case DRSUAPI_ATTRIBUTE_adminDisplayName: val = "DRSUAPI_ATTRIBUTE_adminDisplayName"; break;
1372                         case DRSUAPI_ATTRIBUTE_adminDescription: val = "DRSUAPI_ATTRIBUTE_adminDescription"; break;
1373                         case DRSUAPI_ATTRIBUTE_oMSyntax: val = "DRSUAPI_ATTRIBUTE_oMSyntax"; break;
1374                         case DRSUAPI_ATTRIBUTE_ntSecurityDescriptor: val = "DRSUAPI_ATTRIBUTE_ntSecurityDescriptor"; break;
1375                         case DRSUAPI_ATTRIBUTE_searchFlags: val = "DRSUAPI_ATTRIBUTE_searchFlags"; break;
1376                         case DRSUAPI_ATTRIBUTE_auxiliaryClass: val = "DRSUAPI_ATTRIBUTE_auxiliaryClass"; break;
1377                         case DRSUAPI_ATTRIBUTE_lDAPDisplayName: val = "DRSUAPI_ATTRIBUTE_lDAPDisplayName"; break;
1378                         case DRSUAPI_ATTRIBUTE_name: val = "DRSUAPI_ATTRIBUTE_name"; break;
1379                         case DRSUAPI_ATTRIBUTE_userAccountControl: val = "DRSUAPI_ATTRIBUTE_userAccountControl"; break;
1380                         case DRSUAPI_ATTRIBUTE_currentValue: val = "DRSUAPI_ATTRIBUTE_currentValue"; break;
1381                         case DRSUAPI_ATTRIBUTE_homeDirectory: val = "DRSUAPI_ATTRIBUTE_homeDirectory"; break;
1382                         case DRSUAPI_ATTRIBUTE_homeDrive: val = "DRSUAPI_ATTRIBUTE_homeDrive"; break;
1383                         case DRSUAPI_ATTRIBUTE_scriptPath: val = "DRSUAPI_ATTRIBUTE_scriptPath"; break;
1384                         case DRSUAPI_ATTRIBUTE_profilePath: val = "DRSUAPI_ATTRIBUTE_profilePath"; break;
1385                         case DRSUAPI_ATTRIBUTE_objectSid: val = "DRSUAPI_ATTRIBUTE_objectSid"; break;
1386                         case DRSUAPI_ATTRIBUTE_schemaIDGUID: val = "DRSUAPI_ATTRIBUTE_schemaIDGUID"; break;
1387                         case DRSUAPI_ATTRIBUTE_dBCSPwd: val = "DRSUAPI_ATTRIBUTE_dBCSPwd"; break;
1388                         case DRSUAPI_ATTRIBUTE_logonHours: val = "DRSUAPI_ATTRIBUTE_logonHours"; break;
1389                         case DRSUAPI_ATTRIBUTE_userWorkstations: val = "DRSUAPI_ATTRIBUTE_userWorkstations"; break;
1390                         case DRSUAPI_ATTRIBUTE_unicodePwd: val = "DRSUAPI_ATTRIBUTE_unicodePwd"; break;
1391                         case DRSUAPI_ATTRIBUTE_ntPwdHistory: val = "DRSUAPI_ATTRIBUTE_ntPwdHistory"; break;
1392                         case DRSUAPI_ATTRIBUTE_priorValue: val = "DRSUAPI_ATTRIBUTE_priorValue"; break;
1393                         case DRSUAPI_ATTRIBUTE_supplementalCredentials: val = "DRSUAPI_ATTRIBUTE_supplementalCredentials"; break;
1394                         case DRSUAPI_ATTRIBUTE_trustAuthIncoming: val = "DRSUAPI_ATTRIBUTE_trustAuthIncoming"; break;
1395                         case DRSUAPI_ATTRIBUTE_trustAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_trustAuthOutgoing"; break;
1396                         case DRSUAPI_ATTRIBUTE_lmPwdHistory: val = "DRSUAPI_ATTRIBUTE_lmPwdHistory"; break;
1397                         case DRSUAPI_ATTRIBUTE_systemPossSuperiors: val = "DRSUAPI_ATTRIBUTE_systemPossSuperiors"; break;
1398                         case DRSUAPI_ATTRIBUTE_systemMayContain: val = "DRSUAPI_ATTRIBUTE_systemMayContain"; break;
1399                         case DRSUAPI_ATTRIBUTE_systemMustContain: val = "DRSUAPI_ATTRIBUTE_systemMustContain"; break;
1400                         case DRSUAPI_ATTRIBUTE_systemAuxiliaryClass: val = "DRSUAPI_ATTRIBUTE_systemAuxiliaryClass"; break;
1401                         case DRSUAPI_ATTRIBUTE_sAMAccountName: val = "DRSUAPI_ATTRIBUTE_sAMAccountName"; break;
1402                         case DRSUAPI_ATTRIBUTE_sAMAccountType: val = "DRSUAPI_ATTRIBUTE_sAMAccountType"; break;
1403                         case DRSUAPI_ATTRIBUTE_fSMORoleOwner: val = "DRSUAPI_ATTRIBUTE_fSMORoleOwner"; break;
1404                         case DRSUAPI_ATTRIBUTE_systemFlags: val = "DRSUAPI_ATTRIBUTE_systemFlags"; break;
1405                         case DRSUAPI_ATTRIBUTE_serverReference: val = "DRSUAPI_ATTRIBUTE_serverReference"; break;
1406                         case DRSUAPI_ATTRIBUTE_serverReferenceBL: val = "DRSUAPI_ATTRIBUTE_serverReferenceBL"; break;
1407                         case DRSUAPI_ATTRIBUTE_initialAuthIncoming: val = "DRSUAPI_ATTRIBUTE_initialAuthIncoming"; break;
1408                         case DRSUAPI_ATTRIBUTE_initialAuthOutgoing: val = "DRSUAPI_ATTRIBUTE_initialAuthOutgoing"; break;
1409                         case DRSUAPI_ATTRIBUTE_wellKnownObjects: val = "DRSUAPI_ATTRIBUTE_wellKnownObjects"; break;
1410                         case DRSUAPI_ATTRIBUTE_dNSHostName: val = "DRSUAPI_ATTRIBUTE_dNSHostName"; break;
1411                         case DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet: val = "DRSUAPI_ATTRIBUTE_isMemberOfPartialAttributeSet"; break;
1412                         case DRSUAPI_ATTRIBUTE_userPrincipalName: val = "DRSUAPI_ATTRIBUTE_userPrincipalName"; break;
1413                         case DRSUAPI_ATTRIBUTE_groupType: val = "DRSUAPI_ATTRIBUTE_groupType"; break;
1414                         case DRSUAPI_ATTRIBUTE_servicePrincipalName: val = "DRSUAPI_ATTRIBUTE_servicePrincipalName"; break;
1415                         case DRSUAPI_ATTRIBUTE_objectCategory: val = "DRSUAPI_ATTRIBUTE_objectCategory"; break;
1416                         case DRSUAPI_ATTRIBUTE_gPLink: val = "DRSUAPI_ATTRIBUTE_gPLink"; break;
1417                         case DRSUAPI_ATTRIBUTE_transportAddressAttribute: val = "DRSUAPI_ATTRIBUTE_transportAddressAttribute"; break;
1418                         case DRSUAPI_ATTRIBUTE_msDS_Behavior_Version: val = "DRSUAPI_ATTRIBUTE_msDS_Behavior_Version"; break;
1419                         case DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber: val = "DRSUAPI_ATTRIBUTE_msDS_KeyVersionNumber"; break;
1420                         case DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs: val = "DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs"; break;
1421                         case DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs: val = "DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs"; break;
1422                         case DRSUAPI_ATTRIBUTE_NONE: val = "DRSUAPI_ATTRIBUTE_NONE"; break;
1423                 }
1424                 ndr_print_enum(ndr, name, "ENUM", val, r);
1425                 ndr->flags = _flags_save_ENUM;
1426         }
1427 }
1428
1429 static enum ndr_err_code ndr_push_drsuapi_DsPartialAttributeSet(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsPartialAttributeSet *r)
1430 {
1431         uint32_t cntr_attids_0;
1432         if (ndr_flags & NDR_SCALARS) {
1433                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attids));
1434                 NDR_CHECK(ndr_push_align(ndr, 4));
1435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 1));
1436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attids));
1438                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1439                         NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attids[cntr_attids_0]));
1440                 }
1441                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
1442         }
1443         if (ndr_flags & NDR_BUFFERS) {
1444         }
1445         return NDR_ERR_SUCCESS;
1446 }
1447
1448 static enum ndr_err_code ndr_pull_drsuapi_DsPartialAttributeSet(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsPartialAttributeSet *r)
1449 {
1450         uint32_t cntr_attids_0;
1451         TALLOC_CTX *_mem_save_attids_0;
1452         if (ndr_flags & NDR_SCALARS) {
1453                 NDR_CHECK(ndr_pull_array_size(ndr, &r->attids));
1454                 NDR_CHECK(ndr_pull_align(ndr, 4));
1455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attids));
1458                 if (r->num_attids < 1 || r->num_attids > 0x100000) {
1459                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1460                 }
1461                 NDR_PULL_ALLOC_N(ndr, r->attids, ndr_get_array_size(ndr, &r->attids));
1462                 _mem_save_attids_0 = NDR_PULL_GET_MEM_CTX(ndr);
1463                 NDR_PULL_SET_MEM_CTX(ndr, r->attids, 0);
1464                 for (cntr_attids_0 = 0; cntr_attids_0 < r->num_attids; cntr_attids_0++) {
1465                         NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attids[cntr_attids_0]));
1466                 }
1467                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attids_0, 0);
1468                 if (r->attids) {
1469                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attids, r->num_attids));
1470                 }
1471                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
1472         }
1473         if (ndr_flags & NDR_BUFFERS) {
1474         }
1475         return NDR_ERR_SUCCESS;
1476 }
1477
1478 _PUBLIC_ void ndr_print_drsuapi_DsPartialAttributeSet(struct ndr_print *ndr, const char *name, const struct drsuapi_DsPartialAttributeSet *r)
1479 {
1480         uint32_t cntr_attids_0;
1481         ndr_print_struct(ndr, name, "drsuapi_DsPartialAttributeSet");
1482         ndr->depth++;
1483         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?1:r->version);
1484         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
1485         ndr_print_uint32(ndr, "num_attids", r->num_attids);
1486         ndr->print(ndr, "%s: ARRAY(%d)", "attids", (int)r->num_attids);
1487         ndr->depth++;
1488         for (cntr_attids_0=0;cntr_attids_0<r->num_attids;cntr_attids_0++) {
1489                 char *idx_0=NULL;
1490                 if (asprintf(&idx_0, "[%d]", cntr_attids_0) != -1) {
1491                         ndr_print_drsuapi_DsAttributeId(ndr, "attids", r->attids[cntr_attids_0]);
1492                         free(idx_0);
1493                 }
1494         }
1495         ndr->depth--;
1496         ndr->depth--;
1497 }
1498
1499 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest8(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest8 *r)
1500 {
1501         if (ndr_flags & NDR_SCALARS) {
1502                 NDR_CHECK(ndr_push_align(ndr, 8));
1503                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1504                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1505                 if (r->naming_context == NULL) {
1506                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1507                 }
1508                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1509                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1510                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1511                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
1512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1514                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1515                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1517                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1518                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1519                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1520         }
1521         if (ndr_flags & NDR_BUFFERS) {
1522                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1523                 if (r->uptodateness_vector) {
1524                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1525                 }
1526                 if (r->partial_attribute_set) {
1527                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1528                 }
1529                 if (r->partial_attribute_set_ex) {
1530                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1531                 }
1532                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1533         }
1534         return NDR_ERR_SUCCESS;
1535 }
1536
1537 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest8(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest8 *r)
1538 {
1539         uint32_t _ptr_naming_context;
1540         TALLOC_CTX *_mem_save_naming_context_0;
1541         uint32_t _ptr_uptodateness_vector;
1542         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1543         uint32_t _ptr_partial_attribute_set;
1544         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1545         uint32_t _ptr_partial_attribute_set_ex;
1546         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1547         if (ndr_flags & NDR_SCALARS) {
1548                 NDR_CHECK(ndr_pull_align(ndr, 8));
1549                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1550                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1551                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1552                 if (_ptr_naming_context) {
1553                         NDR_PULL_ALLOC(ndr, r->naming_context);
1554                 } else {
1555                         r->naming_context = NULL;
1556                 }
1557                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1558                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1559                 if (_ptr_uptodateness_vector) {
1560                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1561                 } else {
1562                         r->uptodateness_vector = NULL;
1563                 }
1564                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
1565                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1567                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1568                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1569                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1570                 if (_ptr_partial_attribute_set) {
1571                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1572                 } else {
1573                         r->partial_attribute_set = NULL;
1574                 }
1575                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1576                 if (_ptr_partial_attribute_set_ex) {
1577                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1578                 } else {
1579                         r->partial_attribute_set_ex = NULL;
1580                 }
1581                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1582                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1583         }
1584         if (ndr_flags & NDR_BUFFERS) {
1585                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1586                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1587                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1588                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1589                 if (r->uptodateness_vector) {
1590                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1591                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1592                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1593                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1594                 }
1595                 if (r->partial_attribute_set) {
1596                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1597                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1598                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1599                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1600                 }
1601                 if (r->partial_attribute_set_ex) {
1602                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1603                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1604                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1605                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1606                 }
1607                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1608         }
1609         return NDR_ERR_SUCCESS;
1610 }
1611
1612 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest8(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest8 *r)
1613 {
1614         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest8");
1615         ndr->depth++;
1616         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1617         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1618         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1619         ndr->depth++;
1620         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1621         ndr->depth--;
1622         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1623         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1624         ndr->depth++;
1625         if (r->uptodateness_vector) {
1626                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1627         }
1628         ndr->depth--;
1629         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
1630         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1631         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1632         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1633         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1634         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1635         ndr->depth++;
1636         if (r->partial_attribute_set) {
1637                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1638         }
1639         ndr->depth--;
1640         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1641         ndr->depth++;
1642         if (r->partial_attribute_set_ex) {
1643                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1644         }
1645         ndr->depth--;
1646         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1647         ndr->depth--;
1648 }
1649
1650 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest10(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesRequest10 *r)
1651 {
1652         if (ndr_flags & NDR_SCALARS) {
1653                 NDR_CHECK(ndr_push_align(ndr, 8));
1654                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1655                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1656                 if (r->naming_context == NULL) {
1657                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
1658                 }
1659                 NDR_CHECK(ndr_push_ref_ptr(ndr));
1660                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1661                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
1662                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
1663                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_object_count));
1664                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_ndr_size));
1665                 NDR_CHECK(ndr_push_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, r->extended_op));
1666                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->fsmo_info));
1667                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set));
1668                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->partial_attribute_set_ex));
1669                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_flags));
1671                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1672         }
1673         if (ndr_flags & NDR_BUFFERS) {
1674                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1675                 if (r->uptodateness_vector) {
1676                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1677                 }
1678                 if (r->partial_attribute_set) {
1679                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1680                 }
1681                 if (r->partial_attribute_set_ex) {
1682                         NDR_CHECK(ndr_push_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1683                 }
1684                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1685         }
1686         return NDR_ERR_SUCCESS;
1687 }
1688
1689 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest10(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesRequest10 *r)
1690 {
1691         uint32_t _ptr_naming_context;
1692         TALLOC_CTX *_mem_save_naming_context_0;
1693         uint32_t _ptr_uptodateness_vector;
1694         TALLOC_CTX *_mem_save_uptodateness_vector_0;
1695         uint32_t _ptr_partial_attribute_set;
1696         TALLOC_CTX *_mem_save_partial_attribute_set_0;
1697         uint32_t _ptr_partial_attribute_set_ex;
1698         TALLOC_CTX *_mem_save_partial_attribute_set_ex_0;
1699         if (ndr_flags & NDR_SCALARS) {
1700                 NDR_CHECK(ndr_pull_align(ndr, 8));
1701                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->destination_dsa_guid));
1702                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1703                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
1704                 if (_ptr_naming_context) {
1705                         NDR_PULL_ALLOC(ndr, r->naming_context);
1706                 } else {
1707                         r->naming_context = NULL;
1708                 }
1709                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->highwatermark));
1710                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
1711                 if (_ptr_uptodateness_vector) {
1712                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
1713                 } else {
1714                         r->uptodateness_vector = NULL;
1715                 }
1716                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
1717                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_object_count));
1718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_ndr_size));
1719                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedOperation(ndr, NDR_SCALARS, &r->extended_op));
1720                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->fsmo_info));
1721                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set));
1722                 if (_ptr_partial_attribute_set) {
1723                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set);
1724                 } else {
1725                         r->partial_attribute_set = NULL;
1726                 }
1727                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_partial_attribute_set_ex));
1728                 if (_ptr_partial_attribute_set_ex) {
1729                         NDR_PULL_ALLOC(ndr, r->partial_attribute_set_ex);
1730                 } else {
1731                         r->partial_attribute_set_ex = NULL;
1732                 }
1733                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
1734                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_flags));
1735                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1736         }
1737         if (ndr_flags & NDR_BUFFERS) {
1738                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
1739                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
1740                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
1741                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
1742                 if (r->uptodateness_vector) {
1743                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
1744                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
1745                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
1746                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
1747                 }
1748                 if (r->partial_attribute_set) {
1749                         _mem_save_partial_attribute_set_0 = NDR_PULL_GET_MEM_CTX(ndr);
1750                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set, 0);
1751                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set));
1752                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_0, 0);
1753                 }
1754                 if (r->partial_attribute_set_ex) {
1755                         _mem_save_partial_attribute_set_ex_0 = NDR_PULL_GET_MEM_CTX(ndr);
1756                         NDR_PULL_SET_MEM_CTX(ndr, r->partial_attribute_set_ex, 0);
1757                         NDR_CHECK(ndr_pull_drsuapi_DsPartialAttributeSet(ndr, NDR_SCALARS, r->partial_attribute_set_ex));
1758                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_partial_attribute_set_ex_0, 0);
1759                 }
1760                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
1761         }
1762         return NDR_ERR_SUCCESS;
1763 }
1764
1765 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest10(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesRequest10 *r)
1766 {
1767         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesRequest10");
1768         ndr->depth++;
1769         ndr_print_GUID(ndr, "destination_dsa_guid", &r->destination_dsa_guid);
1770         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1771         ndr_print_ptr(ndr, "naming_context", r->naming_context);
1772         ndr->depth++;
1773         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
1774         ndr->depth--;
1775         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "highwatermark", &r->highwatermark);
1776         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
1777         ndr->depth++;
1778         if (r->uptodateness_vector) {
1779                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
1780         }
1781         ndr->depth--;
1782         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
1783         ndr_print_uint32(ndr, "max_object_count", r->max_object_count);
1784         ndr_print_uint32(ndr, "max_ndr_size", r->max_ndr_size);
1785         ndr_print_drsuapi_DsExtendedOperation(ndr, "extended_op", r->extended_op);
1786         ndr_print_hyper(ndr, "fsmo_info", r->fsmo_info);
1787         ndr_print_ptr(ndr, "partial_attribute_set", r->partial_attribute_set);
1788         ndr->depth++;
1789         if (r->partial_attribute_set) {
1790                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set", r->partial_attribute_set);
1791         }
1792         ndr->depth--;
1793         ndr_print_ptr(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1794         ndr->depth++;
1795         if (r->partial_attribute_set_ex) {
1796                 ndr_print_drsuapi_DsPartialAttributeSet(ndr, "partial_attribute_set_ex", r->partial_attribute_set_ex);
1797         }
1798         ndr->depth--;
1799         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
1800         ndr_print_uint32(ndr, "more_flags", r->more_flags);
1801         ndr->depth--;
1802 }
1803
1804 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesRequest *r)
1805 {
1806         if (ndr_flags & NDR_SCALARS) {
1807                 int level = ndr_push_get_switch_value(ndr, r);
1808                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
1809                 NDR_CHECK(ndr_push_union_align(ndr, 8));
1810                 switch (level) {
1811                         case 5: {
1812                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1813                         break; }
1814
1815                         case 8: {
1816                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1817                         break; }
1818
1819                         case 10: {
1820                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1821                         break; }
1822
1823                         default:
1824                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1825                 }
1826         }
1827         if (ndr_flags & NDR_BUFFERS) {
1828                 int level = ndr_push_get_switch_value(ndr, r);
1829                 switch (level) {
1830                         case 5:
1831                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1832                         break;
1833
1834                         case 8:
1835                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1836                         break;
1837
1838                         case 10:
1839                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1840                         break;
1841
1842                         default:
1843                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1844                 }
1845         }
1846         return NDR_ERR_SUCCESS;
1847 }
1848
1849 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesRequest *r)
1850 {
1851         int level;
1852         int32_t _level;
1853         level = ndr_pull_get_switch_value(ndr, r);
1854         if (ndr_flags & NDR_SCALARS) {
1855                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
1856                 if (_level != level) {
1857                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
1858                 }
1859                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
1860                 switch (level) {
1861                         case 5: {
1862                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_SCALARS, &r->req5));
1863                         break; }
1864
1865                         case 8: {
1866                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_SCALARS, &r->req8));
1867                         break; }
1868
1869                         case 10: {
1870                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_SCALARS, &r->req10));
1871                         break; }
1872
1873                         default:
1874                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1875                 }
1876         }
1877         if (ndr_flags & NDR_BUFFERS) {
1878                 switch (level) {
1879                         case 5:
1880                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest5(ndr, NDR_BUFFERS, &r->req5));
1881                         break;
1882
1883                         case 8:
1884                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest8(ndr, NDR_BUFFERS, &r->req8));
1885                         break;
1886
1887                         case 10:
1888                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest10(ndr, NDR_BUFFERS, &r->req10));
1889                         break;
1890
1891                         default:
1892                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
1893                 }
1894         }
1895         return NDR_ERR_SUCCESS;
1896 }
1897
1898 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesRequest *r)
1899 {
1900         int level;
1901         level = ndr_print_get_switch_value(ndr, r);
1902         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesRequest");
1903         switch (level) {
1904                 case 5:
1905                         ndr_print_drsuapi_DsGetNCChangesRequest5(ndr, "req5", &r->req5);
1906                 break;
1907
1908                 case 8:
1909                         ndr_print_drsuapi_DsGetNCChangesRequest8(ndr, "req8", &r->req8);
1910                 break;
1911
1912                 case 10:
1913                         ndr_print_drsuapi_DsGetNCChangesRequest10(ndr, "req10", &r->req10);
1914                 break;
1915
1916                 default:
1917                         ndr_print_bad_level(ndr, name, level);
1918         }
1919 }
1920
1921 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2 *r)
1922 {
1923         if (ndr_flags & NDR_SCALARS) {
1924                 NDR_CHECK(ndr_push_align(ndr, 8));
1925                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1926                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
1927                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
1928                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1929         }
1930         if (ndr_flags & NDR_BUFFERS) {
1931         }
1932         return NDR_ERR_SUCCESS;
1933 }
1934
1935 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2 *r)
1936 {
1937         if (ndr_flags & NDR_SCALARS) {
1938                 NDR_CHECK(ndr_pull_align(ndr, 8));
1939                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
1940                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
1941                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
1942                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1943         }
1944         if (ndr_flags & NDR_BUFFERS) {
1945         }
1946         return NDR_ERR_SUCCESS;
1947 }
1948
1949 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2 *r)
1950 {
1951         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2");
1952         ndr->depth++;
1953         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
1954         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
1955         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
1956         ndr->depth--;
1957 }
1958
1959 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2CtrEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2CtrEx *r)
1960 {
1961         uint32_t cntr_cursors_0;
1962         if (ndr_flags & NDR_SCALARS) {
1963                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
1964                 NDR_CHECK(ndr_push_align(ndr, 8));
1965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
1966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
1968                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1969                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1970                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1971                 }
1972                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
1973         }
1974         if (ndr_flags & NDR_BUFFERS) {
1975         }
1976         return NDR_ERR_SUCCESS;
1977 }
1978
1979 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2CtrEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2CtrEx *r)
1980 {
1981         uint32_t cntr_cursors_0;
1982         TALLOC_CTX *_mem_save_cursors_0;
1983         if (ndr_flags & NDR_SCALARS) {
1984                 NDR_CHECK(ndr_pull_array_size(ndr, &r->cursors));
1985                 NDR_CHECK(ndr_pull_align(ndr, 8));
1986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
1987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
1988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
1989                 if (r->count > 0x100000) {
1990                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1991                 }
1992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
1993                 NDR_PULL_ALLOC_N(ndr, r->cursors, ndr_get_array_size(ndr, &r->cursors));
1994                 _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
1995                 NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
1996                 for (cntr_cursors_0 = 0; cntr_cursors_0 < r->count; cntr_cursors_0++) {
1997                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->cursors[cntr_cursors_0]));
1998                 }
1999                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
2000                 if (r->cursors) {
2001                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->cursors, r->count));
2002                 }
2003                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2004         }
2005         if (ndr_flags & NDR_BUFFERS) {
2006         }
2007         return NDR_ERR_SUCCESS;
2008 }
2009
2010 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2CtrEx(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2CtrEx *r)
2011 {
2012         uint32_t cntr_cursors_0;
2013         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2CtrEx");
2014         ndr->depth++;
2015         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
2016         ndr_print_uint32(ndr, "reserved1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved1);
2017         ndr_print_uint32(ndr, "count", r->count);
2018         ndr_print_uint32(ndr, "reserved2", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0:r->reserved2);
2019         ndr->print(ndr, "%s: ARRAY(%d)", "cursors", (int)r->count);
2020         ndr->depth++;
2021         for (cntr_cursors_0=0;cntr_cursors_0<r->count;cntr_cursors_0++) {
2022                 char *idx_0=NULL;
2023                 if (asprintf(&idx_0, "[%d]", cntr_cursors_0) != -1) {
2024                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "cursors", &r->cursors[cntr_cursors_0]);
2025                         free(idx_0);
2026                 }
2027         }
2028         ndr->depth--;
2029         ndr->depth--;
2030 }
2031
2032 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValue(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValue *r)
2033 {
2034         if (ndr_flags & NDR_SCALARS) {
2035                 NDR_CHECK(ndr_push_align(ndr, 5));
2036                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->blob, 0)));
2037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->blob));
2038                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2039         }
2040         if (ndr_flags & NDR_BUFFERS) {
2041                 if (r->blob) {
2042                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->blob));
2043                 }
2044         }
2045         return NDR_ERR_SUCCESS;
2046 }
2047
2048 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValue(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValue *r)
2049 {
2050         uint32_t _ptr_blob;
2051         TALLOC_CTX *_mem_save_blob_0;
2052         if (ndr_flags & NDR_SCALARS) {
2053                 NDR_CHECK(ndr_pull_align(ndr, 5));
2054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2055                 if (r->__ndr_size > 10485760) {
2056                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2057                 }
2058                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_blob));
2059                 if (_ptr_blob) {
2060                         NDR_PULL_ALLOC(ndr, r->blob);
2061                 } else {
2062                         r->blob = NULL;
2063                 }
2064                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2065         }
2066         if (ndr_flags & NDR_BUFFERS) {
2067                 if (r->blob) {
2068                         _mem_save_blob_0 = NDR_PULL_GET_MEM_CTX(ndr);
2069                         NDR_PULL_SET_MEM_CTX(ndr, r->blob, 0);
2070                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->blob));
2071                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_blob_0, 0);
2072                 }
2073         }
2074         return NDR_ERR_SUCCESS;
2075 }
2076
2077 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValue(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValue *r)
2078 {
2079         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
2080         ndr->depth++;
2081         ndr_print_uint32(ndr, "__ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_DATA_BLOB(0, r->blob, 0):r->__ndr_size);
2082         ndr_print_ptr(ndr, "blob", r->blob);
2083         ndr->depth++;
2084         if (r->blob) {
2085                 ndr_print_DATA_BLOB(ndr, "blob", *r->blob);
2086         }
2087         ndr->depth--;
2088         ndr->depth--;
2089 }
2090
2091 static enum ndr_err_code ndr_push_drsuapi_DsAttributeValueCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAttributeValueCtr *r)
2092 {
2093         uint32_t cntr_values_1;
2094         if (ndr_flags & NDR_SCALARS) {
2095                 NDR_CHECK(ndr_push_align(ndr, 5));
2096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_values));
2097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->values));
2098                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2099         }
2100         if (ndr_flags & NDR_BUFFERS) {
2101                 if (r->values) {
2102                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_values));
2103                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2104                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2105                         }
2106                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2107                                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2108                         }
2109                 }
2110         }
2111         return NDR_ERR_SUCCESS;
2112 }
2113
2114 static enum ndr_err_code ndr_pull_drsuapi_DsAttributeValueCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAttributeValueCtr *r)
2115 {
2116         uint32_t _ptr_values;
2117         uint32_t cntr_values_1;
2118         TALLOC_CTX *_mem_save_values_0;
2119         TALLOC_CTX *_mem_save_values_1;
2120         if (ndr_flags & NDR_SCALARS) {
2121                 NDR_CHECK(ndr_pull_align(ndr, 5));
2122                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_values));
2123                 if (r->num_values > 10485760) {
2124                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2125                 }
2126                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_values));
2127                 if (_ptr_values) {
2128                         NDR_PULL_ALLOC(ndr, r->values);
2129                 } else {
2130                         r->values = NULL;
2131                 }
2132                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2133         }
2134         if (ndr_flags & NDR_BUFFERS) {
2135                 if (r->values) {
2136                         _mem_save_values_0 = NDR_PULL_GET_MEM_CTX(ndr);
2137                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2138                         NDR_CHECK(ndr_pull_array_size(ndr, &r->values));
2139                         NDR_PULL_ALLOC_N(ndr, r->values, ndr_get_array_size(ndr, &r->values));
2140                         _mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
2141                         NDR_PULL_SET_MEM_CTX(ndr, r->values, 0);
2142                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2143                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->values[cntr_values_1]));
2144                         }
2145                         for (cntr_values_1 = 0; cntr_values_1 < r->num_values; cntr_values_1++) {
2146                                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->values[cntr_values_1]));
2147                         }
2148                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_1, 0);
2149                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_values_0, 0);
2150                 }
2151                 if (r->values) {
2152                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->values, r->num_values));
2153                 }
2154         }
2155         return NDR_ERR_SUCCESS;
2156 }
2157
2158 _PUBLIC_ void ndr_print_drsuapi_DsAttributeValueCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValueCtr *r)
2159 {
2160         uint32_t cntr_values_1;
2161         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValueCtr");
2162         ndr->depth++;
2163         ndr_print_uint32(ndr, "num_values", r->num_values);
2164         ndr_print_ptr(ndr, "values", r->values);
2165         ndr->depth++;
2166         if (r->values) {
2167                 ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->num_values);
2168                 ndr->depth++;
2169                 for (cntr_values_1=0;cntr_values_1<r->num_values;cntr_values_1++) {
2170                         char *idx_1=NULL;
2171                         if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
2172                                 ndr_print_drsuapi_DsAttributeValue(ndr, "values", &r->values[cntr_values_1]);
2173                                 free(idx_1);
2174                         }
2175                 }
2176                 ndr->depth--;
2177         }
2178         ndr->depth--;
2179         ndr->depth--;
2180 }
2181
2182 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2183 {
2184         if (ndr_flags & NDR_SCALARS) {
2185                 NDR_CHECK(ndr_push_align(ndr, 4));
2186                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3(r, ndr->iconv_convenience, ndr->flags)));
2187                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2188                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2189                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2191                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2192                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2193         }
2194         if (ndr_flags & NDR_BUFFERS) {
2195                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2196         }
2197         return NDR_ERR_SUCCESS;
2198 }
2199
2200 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3 *r)
2201 {
2202         if (ndr_flags & NDR_SCALARS) {
2203                 NDR_CHECK(ndr_pull_align(ndr, 4));
2204                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2206                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2207                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2208                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2209                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2210                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2211         }
2212         if (ndr_flags & NDR_BUFFERS) {
2213                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2214         }
2215         return NDR_ERR_SUCCESS;
2216 }
2217
2218 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3 *r)
2219 {
2220         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3");
2221         ndr->depth++;
2222         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);
2223         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);
2224         ndr_print_GUID(ndr, "guid", &r->guid);
2225         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2226         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2227         ndr_print_string(ndr, "dn", r->dn);
2228         ndr->depth--;
2229 }
2230
2231 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3(const struct drsuapi_DsReplicaObjectIdentifier3 *r, struct smb_iconv_convenience *ic, int flags)
2232 {
2233         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3, ic);
2234 }
2235
2236 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2237 {
2238         if (ndr_flags & NDR_SCALARS) {
2239                 NDR_CHECK(ndr_push_align(ndr, 4));
2240                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(r, ndr->iconv_convenience, ndr->flags)));
2241                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_dom_sid28(&r->sid, ndr->flags)));
2242                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
2243                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->dn)));
2245                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dn, strlen_m(r->dn) + 1, sizeof(uint16_t), CH_UTF16));
2246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->binary.length + 4));
2247                 {
2248                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2249                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2250                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
2251                         ndr->flags = _flags_save_DATA_BLOB;
2252                 }
2253                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
2254         }
2255         if (ndr_flags & NDR_BUFFERS) {
2256                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2257         }
2258         return NDR_ERR_SUCCESS;
2259 }
2260
2261 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2262 {
2263         if (ndr_flags & NDR_SCALARS) {
2264                 NDR_CHECK(ndr_pull_align(ndr, 4));
2265                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2266                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_sid));
2267                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
2268                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
2269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_dn));
2270                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dn, r->__ndr_size_dn + 1, sizeof(uint16_t), CH_UTF16));
2271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
2272                 {
2273                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
2274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
2275                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
2276                         ndr->flags = _flags_save_DATA_BLOB;
2277                 }
2278                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
2279         }
2280         if (ndr_flags & NDR_BUFFERS) {
2281                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
2282         }
2283         return NDR_ERR_SUCCESS;
2284 }
2285
2286 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier3Binary(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier3Binary *r)
2287 {
2288         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier3Binary");
2289         ndr->depth++;
2290         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);
2291         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);
2292         ndr_print_GUID(ndr, "guid", &r->guid);
2293         ndr_print_dom_sid28(ndr, "sid", &r->sid);
2294         ndr_print_uint32(ndr, "__ndr_size_dn", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->dn):r->__ndr_size_dn);
2295         ndr_print_string(ndr, "dn", r->dn);
2296         ndr_print_uint32(ndr, "__ndr_size_binary", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->binary.length + 4:r->__ndr_size_binary);
2297         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
2298         ndr->depth--;
2299 }
2300
2301 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttribute *r)
2302 {
2303         if (ndr_flags & NDR_SCALARS) {
2304                 NDR_CHECK(ndr_push_align(ndr, 5));
2305                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2306                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2307                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2308         }
2309         if (ndr_flags & NDR_BUFFERS) {
2310                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2311         }
2312         return NDR_ERR_SUCCESS;
2313 }
2314
2315 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttribute *r)
2316 {
2317         if (ndr_flags & NDR_SCALARS) {
2318                 NDR_CHECK(ndr_pull_align(ndr, 5));
2319                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2320                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_SCALARS, &r->value_ctr));
2321                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2322         }
2323         if (ndr_flags & NDR_BUFFERS) {
2324                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValueCtr(ndr, NDR_BUFFERS, &r->value_ctr));
2325         }
2326         return NDR_ERR_SUCCESS;
2327 }
2328
2329 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttribute *r)
2330 {
2331         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttribute");
2332         ndr->depth++;
2333         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2334         ndr_print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr);
2335         ndr->depth--;
2336 }
2337
2338 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttributeCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttributeCtr *r)
2339 {
2340         uint32_t cntr_attributes_1;
2341         if (ndr_flags & NDR_SCALARS) {
2342                 NDR_CHECK(ndr_push_align(ndr, 5));
2343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_attributes));
2344                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attributes));
2345                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2346         }
2347         if (ndr_flags & NDR_BUFFERS) {
2348                 if (r->attributes) {
2349                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_attributes));
2350                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2351                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2352                         }
2353                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2354                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2355                         }
2356                 }
2357         }
2358         return NDR_ERR_SUCCESS;
2359 }
2360
2361 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttributeCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttributeCtr *r)
2362 {
2363         uint32_t _ptr_attributes;
2364         uint32_t cntr_attributes_1;
2365         TALLOC_CTX *_mem_save_attributes_0;
2366         TALLOC_CTX *_mem_save_attributes_1;
2367         if (ndr_flags & NDR_SCALARS) {
2368                 NDR_CHECK(ndr_pull_align(ndr, 5));
2369                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_attributes));
2370                 if (r->num_attributes > 1048576) {
2371                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2372                 }
2373                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attributes));
2374                 if (_ptr_attributes) {
2375                         NDR_PULL_ALLOC(ndr, r->attributes);
2376                 } else {
2377                         r->attributes = NULL;
2378                 }
2379                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2380         }
2381         if (ndr_flags & NDR_BUFFERS) {
2382                 if (r->attributes) {
2383                         _mem_save_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
2384                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2385                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attributes));
2386                         NDR_PULL_ALLOC_N(ndr, r->attributes, ndr_get_array_size(ndr, &r->attributes));
2387                         _mem_save_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
2388                         NDR_PULL_SET_MEM_CTX(ndr, r->attributes, 0);
2389                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2390                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_SCALARS, &r->attributes[cntr_attributes_1]));
2391                         }
2392                         for (cntr_attributes_1 = 0; cntr_attributes_1 < r->num_attributes; cntr_attributes_1++) {
2393                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttribute(ndr, NDR_BUFFERS, &r->attributes[cntr_attributes_1]));
2394                         }
2395                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_1, 0);
2396                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attributes_0, 0);
2397                 }
2398                 if (r->attributes) {
2399                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->attributes, r->num_attributes));
2400                 }
2401         }
2402         return NDR_ERR_SUCCESS;
2403 }
2404
2405 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttributeCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttributeCtr *r)
2406 {
2407         uint32_t cntr_attributes_1;
2408         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttributeCtr");
2409         ndr->depth++;
2410         ndr_print_uint32(ndr, "num_attributes", r->num_attributes);
2411         ndr_print_ptr(ndr, "attributes", r->attributes);
2412         ndr->depth++;
2413         if (r->attributes) {
2414                 ndr->print(ndr, "%s: ARRAY(%d)", "attributes", (int)r->num_attributes);
2415                 ndr->depth++;
2416                 for (cntr_attributes_1=0;cntr_attributes_1<r->num_attributes;cntr_attributes_1++) {
2417                         char *idx_1=NULL;
2418                         if (asprintf(&idx_1, "[%d]", cntr_attributes_1) != -1) {
2419                                 ndr_print_drsuapi_DsReplicaAttribute(ndr, "attributes", &r->attributes[cntr_attributes_1]);
2420                                 free(idx_1);
2421                         }
2422                 }
2423                 ndr->depth--;
2424         }
2425         ndr->depth--;
2426         ndr->depth--;
2427 }
2428
2429 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2430 {
2431         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2432         return NDR_ERR_SUCCESS;
2433 }
2434
2435 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2436 {
2437         uint32_t v;
2438         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2439         *r = v;
2440         return NDR_ERR_SUCCESS;
2441 }
2442
2443 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2444 {
2445         ndr_print_uint32(ndr, name, r);
2446         ndr->depth++;
2447         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER", DRSUAPI_DS_REPLICA_OBJECT_FROM_MASTER, r);
2448         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC", DRSUAPI_DS_REPLICA_OBJECT_DYNAMIC, r);
2449         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY", DRSUAPI_DS_REPLICA_OBJECT_REMOTE_MODIFY, r);
2450         ndr->depth--;
2451 }
2452
2453 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObject(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObject *r)
2454 {
2455         if (ndr_flags & NDR_SCALARS) {
2456                 NDR_CHECK(ndr_push_align(ndr, 5));
2457                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2458                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, r->flags));
2459                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2460                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2461         }
2462         if (ndr_flags & NDR_BUFFERS) {
2463                 if (r->identifier) {
2464                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2465                 }
2466                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2467         }
2468         return NDR_ERR_SUCCESS;
2469 }
2470
2471 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObject(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObject *r)
2472 {
2473         uint32_t _ptr_identifier;
2474         TALLOC_CTX *_mem_save_identifier_0;
2475         if (ndr_flags & NDR_SCALARS) {
2476                 NDR_CHECK(ndr_pull_align(ndr, 5));
2477                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2478                 if (_ptr_identifier) {
2479                         NDR_PULL_ALLOC(ndr, r->identifier);
2480                 } else {
2481                         r->identifier = NULL;
2482                 }
2483                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectFlags(ndr, NDR_SCALARS, &r->flags));
2484                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_SCALARS, &r->attribute_ctr));
2485                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2486         }
2487         if (ndr_flags & NDR_BUFFERS) {
2488                 if (r->identifier) {
2489                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2490                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2491                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2492                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2493                 }
2494                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttributeCtr(ndr, NDR_BUFFERS, &r->attribute_ctr));
2495         }
2496         return NDR_ERR_SUCCESS;
2497 }
2498
2499 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObject(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObject *r)
2500 {
2501         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObject");
2502         ndr->depth++;
2503         ndr_print_ptr(ndr, "identifier", r->identifier);
2504         ndr->depth++;
2505         if (r->identifier) {
2506                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2507         }
2508         ndr->depth--;
2509         ndr_print_drsuapi_DsReplicaObjectFlags(ndr, "flags", r->flags);
2510         ndr_print_drsuapi_DsReplicaAttributeCtr(ndr, "attribute_ctr", &r->attribute_ctr);
2511         ndr->depth--;
2512 }
2513
2514 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaData *r)
2515 {
2516         if (ndr_flags & NDR_SCALARS) {
2517                 NDR_CHECK(ndr_push_align(ndr, 8));
2518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
2519                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_change_time));
2520                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2521                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
2522                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2523         }
2524         if (ndr_flags & NDR_BUFFERS) {
2525         }
2526         return NDR_ERR_SUCCESS;
2527 }
2528
2529 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaData *r)
2530 {
2531         if (ndr_flags & NDR_SCALARS) {
2532                 NDR_CHECK(ndr_pull_align(ndr, 8));
2533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
2534                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_change_time));
2535                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
2536                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
2537                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2538         }
2539         if (ndr_flags & NDR_BUFFERS) {
2540         }
2541         return NDR_ERR_SUCCESS;
2542 }
2543
2544 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaData *r)
2545 {
2546         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaData");
2547         ndr->depth++;
2548         ndr_print_uint32(ndr, "version", r->version);
2549         ndr_print_NTTIME_1sec(ndr, "originating_change_time", r->originating_change_time);
2550         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
2551         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
2552         ndr->depth--;
2553 }
2554
2555 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaMetaDataCtr *r)
2556 {
2557         uint32_t cntr_meta_data_0;
2558         if (ndr_flags & NDR_SCALARS) {
2559                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
2560                 NDR_CHECK(ndr_push_align(ndr, 8));
2561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
2562                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2563                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2564                 }
2565                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2566         }
2567         if (ndr_flags & NDR_BUFFERS) {
2568         }
2569         return NDR_ERR_SUCCESS;
2570 }
2571
2572 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaMetaDataCtr *r)
2573 {
2574         uint32_t cntr_meta_data_0;
2575         TALLOC_CTX *_mem_save_meta_data_0;
2576         if (ndr_flags & NDR_SCALARS) {
2577                 NDR_CHECK(ndr_pull_array_size(ndr, &r->meta_data));
2578                 NDR_CHECK(ndr_pull_align(ndr, 8));
2579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
2580                 if (r->count > 1048576) {
2581                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2582                 }
2583                 NDR_PULL_ALLOC_N(ndr, r->meta_data, ndr_get_array_size(ndr, &r->meta_data));
2584                 _mem_save_meta_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
2585                 NDR_PULL_SET_MEM_CTX(ndr, r->meta_data, 0);
2586                 for (cntr_meta_data_0 = 0; cntr_meta_data_0 < r->count; cntr_meta_data_0++) {
2587                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data[cntr_meta_data_0]));
2588                 }
2589                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_0, 0);
2590                 if (r->meta_data) {
2591                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->meta_data, r->count));
2592                 }
2593                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2594         }
2595         if (ndr_flags & NDR_BUFFERS) {
2596         }
2597         return NDR_ERR_SUCCESS;
2598 }
2599
2600 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaMetaDataCtr *r)
2601 {
2602         uint32_t cntr_meta_data_0;
2603         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMetaDataCtr");
2604         ndr->depth++;
2605         ndr_print_uint32(ndr, "count", r->count);
2606         ndr->print(ndr, "%s: ARRAY(%d)", "meta_data", (int)r->count);
2607         ndr->depth++;
2608         for (cntr_meta_data_0=0;cntr_meta_data_0<r->count;cntr_meta_data_0++) {
2609                 char *idx_0=NULL;
2610                 if (asprintf(&idx_0, "[%d]", cntr_meta_data_0) != -1) {
2611                         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data[cntr_meta_data_0]);
2612                         free(idx_0);
2613                 }
2614         }
2615         ndr->depth--;
2616         ndr->depth--;
2617 }
2618
2619 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItemEx(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItemEx *r)
2620 {
2621         if (ndr_flags & NDR_SCALARS) {
2622                 NDR_CHECK(ndr_push_align(ndr, 5));
2623                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
2624                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_nc_prefix));
2626                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parent_object_guid));
2627                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->meta_data_ctr));
2628                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
2629         }
2630         if (ndr_flags & NDR_BUFFERS) {
2631                 if (r->next_object) {
2632                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2633                 }
2634                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2635                 if (r->parent_object_guid) {
2636                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2637                 }
2638                 if (r->meta_data_ctr) {
2639                         NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2640                 }
2641         }
2642         return NDR_ERR_SUCCESS;
2643 }
2644
2645 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItemEx(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItemEx *r)
2646 {
2647         uint32_t _ptr_next_object;
2648         TALLOC_CTX *_mem_save_next_object_0;
2649         uint32_t _ptr_parent_object_guid;
2650         TALLOC_CTX *_mem_save_parent_object_guid_0;
2651         uint32_t _ptr_meta_data_ctr;
2652         TALLOC_CTX *_mem_save_meta_data_ctr_0;
2653         if (ndr_flags & NDR_SCALARS) {
2654                 NDR_CHECK(ndr_pull_align(ndr, 5));
2655                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
2656                 if (_ptr_next_object) {
2657                         NDR_PULL_ALLOC(ndr, r->next_object);
2658                 } else {
2659                         r->next_object = NULL;
2660                 }
2661                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
2662                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_nc_prefix));
2663                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parent_object_guid));
2664                 if (_ptr_parent_object_guid) {
2665                         NDR_PULL_ALLOC(ndr, r->parent_object_guid);
2666                 } else {
2667                         r->parent_object_guid = NULL;
2668                 }
2669                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_meta_data_ctr));
2670                 if (_ptr_meta_data_ctr) {
2671                         NDR_PULL_ALLOC(ndr, r->meta_data_ctr);
2672                 } else {
2673                         r->meta_data_ctr = NULL;
2674                 }
2675                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
2676         }
2677         if (ndr_flags & NDR_BUFFERS) {
2678                 if (r->next_object) {
2679                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2680                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
2681                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
2682                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
2683                 }
2684                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
2685                 if (r->parent_object_guid) {
2686                         _mem_save_parent_object_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2687                         NDR_PULL_SET_MEM_CTX(ndr, r->parent_object_guid, 0);
2688                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->parent_object_guid));
2689                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parent_object_guid_0, 0);
2690                 }
2691                 if (r->meta_data_ctr) {
2692                         _mem_save_meta_data_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
2693                         NDR_PULL_SET_MEM_CTX(ndr, r->meta_data_ctr, 0);
2694                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaDataCtr(ndr, NDR_SCALARS, r->meta_data_ctr));
2695                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_meta_data_ctr_0, 0);
2696                 }
2697         }
2698         return NDR_ERR_SUCCESS;
2699 }
2700
2701 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1 *r)
2702 {
2703         if (ndr_flags & NDR_SCALARS) {
2704                 NDR_CHECK(ndr_push_align(ndr, 8));
2705                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2706                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2707                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2708                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2709                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2710                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2711                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2712                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr1(r, ndr->iconv_convenience, ndr->flags) + 55));
2715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2717                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2718         }
2719         if (ndr_flags & NDR_BUFFERS) {
2720                 if (r->naming_context) {
2721                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2722                 }
2723                 if (r->uptodateness_vector) {
2724                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2725                 }
2726                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2727                 if (r->first_object) {
2728                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2729                 }
2730         }
2731         return NDR_ERR_SUCCESS;
2732 }
2733
2734 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1 *r)
2735 {
2736         uint32_t _ptr_naming_context;
2737         TALLOC_CTX *_mem_save_naming_context_0;
2738         uint32_t _ptr_uptodateness_vector;
2739         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2740         uint32_t _ptr_first_object;
2741         TALLOC_CTX *_mem_save_first_object_0;
2742         if (ndr_flags & NDR_SCALARS) {
2743                 NDR_CHECK(ndr_pull_align(ndr, 8));
2744                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2745                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2746                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2747                 if (_ptr_naming_context) {
2748                         NDR_PULL_ALLOC(ndr, r->naming_context);
2749                 } else {
2750                         r->naming_context = NULL;
2751                 }
2752                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2753                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2754                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
2755                 if (_ptr_uptodateness_vector) {
2756                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
2757                 } else {
2758                         r->uptodateness_vector = NULL;
2759                 }
2760                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2761                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
2762                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
2763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
2764                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
2765                 if (_ptr_first_object) {
2766                         NDR_PULL_ALLOC(ndr, r->first_object);
2767                 } else {
2768                         r->first_object = NULL;
2769                 }
2770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
2771                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2772         }
2773         if (ndr_flags & NDR_BUFFERS) {
2774                 if (r->naming_context) {
2775                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
2776                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
2777                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2778                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
2779                 }
2780                 if (r->uptodateness_vector) {
2781                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
2782                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
2783                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2784                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
2785                 }
2786                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2787                 if (r->first_object) {
2788                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
2789                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
2790                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2791                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
2792                 }
2793         }
2794         return NDR_ERR_SUCCESS;
2795 }
2796
2797 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1 *r)
2798 {
2799         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1");
2800         ndr->depth++;
2801         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
2802         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
2803         ndr_print_ptr(ndr, "naming_context", r->naming_context);
2804         ndr->depth++;
2805         if (r->naming_context) {
2806                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
2807         }
2808         ndr->depth--;
2809         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
2810         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
2811         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
2812         ndr->depth++;
2813         if (r->uptodateness_vector) {
2814                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
2815         }
2816         ndr->depth--;
2817         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
2818         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
2819         ndr_print_uint32(ndr, "object_count", r->object_count);
2820         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);
2821         ndr_print_ptr(ndr, "first_object", r->first_object);
2822         ndr->depth++;
2823         if (r->first_object) {
2824                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
2825         }
2826         ndr->depth--;
2827         ndr_print_uint32(ndr, "more_data", r->more_data);
2828         ndr->depth--;
2829 }
2830
2831 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr1(const struct drsuapi_DsGetNCChangesCtr1 *r, struct smb_iconv_convenience *ic, int flags)
2832 {
2833         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr1, ic);
2834 }
2835
2836 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsLinkedAttributeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2837 {
2838         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2839         return NDR_ERR_SUCCESS;
2840 }
2841
2842 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsLinkedAttributeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2843 {
2844         uint32_t v;
2845         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2846         *r = v;
2847         return NDR_ERR_SUCCESS;
2848 }
2849
2850 _PUBLIC_ void ndr_print_drsuapi_DsLinkedAttributeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
2851 {
2852         ndr_print_uint32(ndr, name, r);
2853         ndr->depth++;
2854         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE", DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE, r);
2855         ndr->depth--;
2856 }
2857
2858 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaLinkedAttribute(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaLinkedAttribute *r)
2859 {
2860         if (ndr_flags & NDR_SCALARS) {
2861                 NDR_CHECK(ndr_push_align(ndr, 8));
2862                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->identifier));
2863                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
2864                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2865                 NDR_CHECK(ndr_push_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, r->flags));
2866                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->originating_add_time));
2867                 NDR_CHECK(ndr_push_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2868                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2869         }
2870         if (ndr_flags & NDR_BUFFERS) {
2871                 if (r->identifier) {
2872                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2873                 }
2874                 NDR_CHECK(ndr_push_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2875         }
2876         return NDR_ERR_SUCCESS;
2877 }
2878
2879 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaLinkedAttribute(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaLinkedAttribute *r)
2880 {
2881         uint32_t _ptr_identifier;
2882         TALLOC_CTX *_mem_save_identifier_0;
2883         if (ndr_flags & NDR_SCALARS) {
2884                 NDR_CHECK(ndr_pull_align(ndr, 8));
2885                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_identifier));
2886                 if (_ptr_identifier) {
2887                         NDR_PULL_ALLOC(ndr, r->identifier);
2888                 } else {
2889                         r->identifier = NULL;
2890                 }
2891                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
2892                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_SCALARS, &r->value));
2893                 NDR_CHECK(ndr_pull_drsuapi_DsLinkedAttributeFlags(ndr, NDR_SCALARS, &r->flags));
2894                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->originating_add_time));
2895                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaMetaData(ndr, NDR_SCALARS, &r->meta_data));
2896                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
2897         }
2898         if (ndr_flags & NDR_BUFFERS) {
2899                 if (r->identifier) {
2900                         _mem_save_identifier_0 = NDR_PULL_GET_MEM_CTX(ndr);
2901                         NDR_PULL_SET_MEM_CTX(ndr, r->identifier, 0);
2902                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->identifier));
2903                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_identifier_0, 0);
2904                 }
2905                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeValue(ndr, NDR_BUFFERS, &r->value));
2906         }
2907         return NDR_ERR_SUCCESS;
2908 }
2909
2910 _PUBLIC_ void ndr_print_drsuapi_DsReplicaLinkedAttribute(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaLinkedAttribute *r)
2911 {
2912         ndr_print_struct(ndr, name, "drsuapi_DsReplicaLinkedAttribute");
2913         ndr->depth++;
2914         ndr_print_ptr(ndr, "identifier", r->identifier);
2915         ndr->depth++;
2916         if (r->identifier) {
2917                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "identifier", r->identifier);
2918         }
2919         ndr->depth--;
2920         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
2921         ndr_print_drsuapi_DsAttributeValue(ndr, "value", &r->value);
2922         ndr_print_drsuapi_DsLinkedAttributeFlags(ndr, "flags", r->flags);
2923         ndr_print_NTTIME_1sec(ndr, "originating_add_time", r->originating_add_time);
2924         ndr_print_drsuapi_DsReplicaMetaData(ndr, "meta_data", &r->meta_data);
2925         ndr->depth--;
2926 }
2927
2928 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6 *r)
2929 {
2930         uint32_t cntr_linked_attributes_1;
2931         if (ndr_flags & NDR_SCALARS) {
2932                 NDR_CHECK(ndr_push_align(ndr, 8));
2933                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2934                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2935                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context));
2936                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2937                 NDR_CHECK(ndr_push_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
2938                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->uptodateness_vector));
2939                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
2940                 NDR_CHECK(ndr_push_drsuapi_DsExtendedError(ndr, NDR_SCALARS, r->extended_ret));
2941                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->object_count));
2942                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsGetNCChangesCtr6(r, ndr->iconv_convenience, ndr->flags) + 55));
2943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->first_object));
2944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->more_data));
2945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_object_count));
2946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->nc_linked_attributes_count));
2947                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->linked_attributes_count));
2948                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linked_attributes));
2949                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->drs_error));
2950                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
2951         }
2952         if (ndr_flags & NDR_BUFFERS) {
2953                 if (r->naming_context) {
2954                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
2955                 }
2956                 if (r->uptodateness_vector) {
2957                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
2958                 }
2959                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
2960                 if (r->first_object) {
2961                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
2962                 }
2963                 if (r->linked_attributes) {
2964                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->linked_attributes_count));
2965                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2966                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
2967                         }
2968                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
2969                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
2970                         }
2971                 }
2972         }
2973         return NDR_ERR_SUCCESS;
2974 }
2975
2976 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6 *r)
2977 {
2978         uint32_t _ptr_naming_context;
2979         TALLOC_CTX *_mem_save_naming_context_0;
2980         uint32_t _ptr_uptodateness_vector;
2981         TALLOC_CTX *_mem_save_uptodateness_vector_0;
2982         uint32_t _ptr_first_object;
2983         TALLOC_CTX *_mem_save_first_object_0;
2984         uint32_t _ptr_linked_attributes;
2985         uint32_t cntr_linked_attributes_1;
2986         TALLOC_CTX *_mem_save_linked_attributes_0;
2987         TALLOC_CTX *_mem_save_linked_attributes_1;
2988         if (ndr_flags & NDR_SCALARS) {
2989                 NDR_CHECK(ndr_pull_align(ndr, 8));
2990                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_guid));
2991                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
2992                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context));
2993                 if (_ptr_naming_context) {
2994                         NDR_PULL_ALLOC(ndr, r->naming_context);
2995                 } else {
2996                         r->naming_context = NULL;
2997                 }
2998                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->old_highwatermark));
2999                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaHighWaterMark(ndr, NDR_SCALARS, &r->new_highwatermark));
3000                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_uptodateness_vector));
3001                 if (_ptr_uptodateness_vector) {
3002                         NDR_PULL_ALLOC(ndr, r->uptodateness_vector);
3003                 } else {
3004                         r->uptodateness_vector = NULL;
3005                 }
3006                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_SCALARS, &r->mapping_ctr));
3007                 NDR_CHECK(ndr_pull_drsuapi_DsExtendedError(ndr, NDR_SCALARS, &r->extended_ret));
3008                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->object_count));
3009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
3010                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_first_object));
3011                 if (_ptr_first_object) {
3012                         NDR_PULL_ALLOC(ndr, r->first_object);
3013                 } else {
3014                         r->first_object = NULL;
3015                 }
3016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->more_data));
3017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_object_count));
3018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->nc_linked_attributes_count));
3019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->linked_attributes_count));
3020                 if (r->linked_attributes_count > 1048576) {
3021                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3022                 }
3023                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linked_attributes));
3024                 if (_ptr_linked_attributes) {
3025                         NDR_PULL_ALLOC(ndr, r->linked_attributes);
3026                 } else {
3027                         r->linked_attributes = NULL;
3028                 }
3029                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->drs_error));
3030                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
3031         }
3032         if (ndr_flags & NDR_BUFFERS) {
3033                 if (r->naming_context) {
3034                         _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3035                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3036                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3037                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3038                 }
3039                 if (r->uptodateness_vector) {
3040                         _mem_save_uptodateness_vector_0 = NDR_PULL_GET_MEM_CTX(ndr);
3041                         NDR_PULL_SET_MEM_CTX(ndr, r->uptodateness_vector, 0);
3042                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2CtrEx(ndr, NDR_SCALARS, r->uptodateness_vector));
3043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_uptodateness_vector_0, 0);
3044                 }
3045                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOIDMapping_Ctr(ndr, NDR_BUFFERS, &r->mapping_ctr));
3046                 if (r->first_object) {
3047                         _mem_save_first_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
3048                         NDR_PULL_SET_MEM_CTX(ndr, r->first_object, 0);
3049                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItemEx(ndr, NDR_SCALARS|NDR_BUFFERS, r->first_object));
3050                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_first_object_0, 0);
3051                 }
3052                 if (r->linked_attributes) {
3053                         _mem_save_linked_attributes_0 = NDR_PULL_GET_MEM_CTX(ndr);
3054                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3055                         NDR_CHECK(ndr_pull_array_size(ndr, &r->linked_attributes));
3056                         NDR_PULL_ALLOC_N(ndr, r->linked_attributes, ndr_get_array_size(ndr, &r->linked_attributes));
3057                         _mem_save_linked_attributes_1 = NDR_PULL_GET_MEM_CTX(ndr);
3058                         NDR_PULL_SET_MEM_CTX(ndr, r->linked_attributes, 0);
3059                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3060                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_SCALARS, &r->linked_attributes[cntr_linked_attributes_1]));
3061                         }
3062                         for (cntr_linked_attributes_1 = 0; cntr_linked_attributes_1 < r->linked_attributes_count; cntr_linked_attributes_1++) {
3063                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaLinkedAttribute(ndr, NDR_BUFFERS, &r->linked_attributes[cntr_linked_attributes_1]));
3064                         }
3065                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_1, 0);
3066                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linked_attributes_0, 0);
3067                 }
3068                 if (r->linked_attributes) {
3069                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->linked_attributes, r->linked_attributes_count));
3070                 }
3071         }
3072         return NDR_ERR_SUCCESS;
3073 }
3074
3075 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6 *r)
3076 {
3077         uint32_t cntr_linked_attributes_1;
3078         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6");
3079         ndr->depth++;
3080         ndr_print_GUID(ndr, "source_dsa_guid", &r->source_dsa_guid);
3081         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
3082         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3083         ndr->depth++;
3084         if (r->naming_context) {
3085                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3086         }
3087         ndr->depth--;
3088         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "old_highwatermark", &r->old_highwatermark);
3089         ndr_print_drsuapi_DsReplicaHighWaterMark(ndr, "new_highwatermark", &r->new_highwatermark);
3090         ndr_print_ptr(ndr, "uptodateness_vector", r->uptodateness_vector);
3091         ndr->depth++;
3092         if (r->uptodateness_vector) {
3093                 ndr_print_drsuapi_DsReplicaCursor2CtrEx(ndr, "uptodateness_vector", r->uptodateness_vector);
3094         }
3095         ndr->depth--;
3096         ndr_print_drsuapi_DsReplicaOIDMapping_Ctr(ndr, "mapping_ctr", &r->mapping_ctr);
3097         ndr_print_drsuapi_DsExtendedError(ndr, "extended_ret", r->extended_ret);
3098         ndr_print_uint32(ndr, "object_count", r->object_count);
3099         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);
3100         ndr_print_ptr(ndr, "first_object", r->first_object);
3101         ndr->depth++;
3102         if (r->first_object) {
3103                 ndr_print_drsuapi_DsReplicaObjectListItemEx(ndr, "first_object", r->first_object);
3104         }
3105         ndr->depth--;
3106         ndr_print_uint32(ndr, "more_data", r->more_data);
3107         ndr_print_uint32(ndr, "nc_object_count", r->nc_object_count);
3108         ndr_print_uint32(ndr, "nc_linked_attributes_count", r->nc_linked_attributes_count);
3109         ndr_print_uint32(ndr, "linked_attributes_count", r->linked_attributes_count);
3110         ndr_print_ptr(ndr, "linked_attributes", r->linked_attributes);
3111         ndr->depth++;
3112         if (r->linked_attributes) {
3113                 ndr->print(ndr, "%s: ARRAY(%d)", "linked_attributes", (int)r->linked_attributes_count);
3114                 ndr->depth++;
3115                 for (cntr_linked_attributes_1=0;cntr_linked_attributes_1<r->linked_attributes_count;cntr_linked_attributes_1++) {
3116                         char *idx_1=NULL;
3117                         if (asprintf(&idx_1, "[%d]", cntr_linked_attributes_1) != -1) {
3118                                 ndr_print_drsuapi_DsReplicaLinkedAttribute(ndr, "linked_attributes", &r->linked_attributes[cntr_linked_attributes_1]);
3119                                 free(idx_1);
3120                         }
3121                 }
3122                 ndr->depth--;
3123         }
3124         ndr->depth--;
3125         ndr_print_WERROR(ndr, "drs_error", r->drs_error);
3126         ndr->depth--;
3127 }
3128
3129 _PUBLIC_ size_t ndr_size_drsuapi_DsGetNCChangesCtr6(const struct drsuapi_DsGetNCChangesCtr6 *r, struct smb_iconv_convenience *ic, int flags)
3130 {
3131         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsGetNCChangesCtr6, ic);
3132 }
3133
3134 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr1TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3135 {
3136         if (ndr_flags & NDR_SCALARS) {
3137                 NDR_CHECK(ndr_push_align(ndr, 1));
3138                 {
3139                         struct ndr_push *_ndr_ctr1;
3140                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3141                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3142                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3143                 }
3144                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3145         }
3146         if (ndr_flags & NDR_BUFFERS) {
3147         }
3148         return NDR_ERR_SUCCESS;
3149 }
3150
3151 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr1TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr1TS *r)
3152 {
3153         if (ndr_flags & NDR_SCALARS) {
3154                 NDR_CHECK(ndr_pull_align(ndr, 1));
3155                 {
3156                         struct ndr_pull *_ndr_ctr1;
3157                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr1, 0xFFFFFC01, -1));
3158                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(_ndr_ctr1, NDR_SCALARS|NDR_BUFFERS, &r->ctr1));
3159                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr1, 0xFFFFFC01, -1));
3160                 }
3161                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3162         }
3163         if (ndr_flags & NDR_BUFFERS) {
3164         }
3165         return NDR_ERR_SUCCESS;
3166 }
3167
3168 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr1TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr1TS *r)
3169 {
3170         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr1TS");
3171         ndr->depth++;
3172         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3173         ndr->depth--;
3174 }
3175
3176 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr6TS(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3177 {
3178         if (ndr_flags & NDR_SCALARS) {
3179                 NDR_CHECK(ndr_push_align(ndr, 1));
3180                 {
3181                         struct ndr_push *_ndr_ctr6;
3182                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3183                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3184                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3185                 }
3186                 NDR_CHECK(ndr_push_trailer_align(ndr, 1));
3187         }
3188         if (ndr_flags & NDR_BUFFERS) {
3189         }
3190         return NDR_ERR_SUCCESS;
3191 }
3192
3193 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr6TS(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr6TS *r)
3194 {
3195         if (ndr_flags & NDR_SCALARS) {
3196                 NDR_CHECK(ndr_pull_align(ndr, 1));
3197                 {
3198                         struct ndr_pull *_ndr_ctr6;
3199                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ctr6, 0xFFFFFC01, -1));
3200                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(_ndr_ctr6, NDR_SCALARS|NDR_BUFFERS, &r->ctr6));
3201                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ctr6, 0xFFFFFC01, -1));
3202                 }
3203                 NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
3204         }
3205         if (ndr_flags & NDR_BUFFERS) {
3206         }
3207         return NDR_ERR_SUCCESS;
3208 }
3209
3210 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr6TS(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr6TS *r)
3211 {
3212         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr6TS");
3213         ndr->depth++;
3214         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3215         ndr->depth--;
3216 }
3217
3218 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3219 {
3220         uint32_t _ptr_ts;
3221         TALLOC_CTX *_mem_save_ts_0;
3222         if (ndr_flags & NDR_SCALARS) {
3223                 NDR_CHECK(ndr_pull_align(ndr, 5));
3224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3225                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3226                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3227                 if (_ptr_ts) {
3228                         NDR_PULL_ALLOC(ndr, r->ts);
3229                 } else {
3230                         r->ts = NULL;
3231                 }
3232                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3233         }
3234         if (ndr_flags & NDR_BUFFERS) {
3235                 if (r->ts) {
3236                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3237                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3238                         {
3239                                 struct ndr_pull *_ndr_ts;
3240                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3241                                 {
3242                                         struct ndr_pull *_ndr_ts_compressed;
3243                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3244                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3245                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3246                                 }
3247                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3248                         }
3249                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3250                 }
3251         }
3252         return NDR_ERR_SUCCESS;
3253 }
3254
3255 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr1 *r)
3256 {
3257         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr1");
3258         ndr->depth++;
3259         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3260         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3261         ndr_print_ptr(ndr, "ts", r->ts);
3262         ndr->depth++;
3263         if (r->ts) {
3264                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3265         }
3266         ndr->depth--;
3267         ndr->depth--;
3268 }
3269
3270 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3271 {
3272         uint32_t _ptr_ts;
3273         TALLOC_CTX *_mem_save_ts_0;
3274         if (ndr_flags & NDR_SCALARS) {
3275                 NDR_CHECK(ndr_pull_align(ndr, 5));
3276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3277                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3278                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3279                 if (_ptr_ts) {
3280                         NDR_PULL_ALLOC(ndr, r->ts);
3281                 } else {
3282                         r->ts = NULL;
3283                 }
3284                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3285         }
3286         if (ndr_flags & NDR_BUFFERS) {
3287                 if (r->ts) {
3288                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3289                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3290                         {
3291                                 struct ndr_pull *_ndr_ts;
3292                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3293                                 {
3294                                         struct ndr_pull *_ndr_ts_compressed;
3295                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3296                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3297                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_MSZIP, r->decompressed_length));
3298                                 }
3299                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3300                         }
3301                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3302                 }
3303         }
3304         return NDR_ERR_SUCCESS;
3305 }
3306
3307 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesMSZIPCtr6 *r)
3308 {
3309         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesMSZIPCtr6");
3310         ndr->depth++;
3311         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3312         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3313         ndr_print_ptr(ndr, "ts", r->ts);
3314         ndr->depth++;
3315         if (r->ts) {
3316                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3317         }
3318         ndr->depth--;
3319         ndr->depth--;
3320 }
3321
3322 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3323 {
3324         uint32_t _ptr_ts;
3325         TALLOC_CTX *_mem_save_ts_0;
3326         if (ndr_flags & NDR_SCALARS) {
3327                 NDR_CHECK(ndr_pull_align(ndr, 5));
3328                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3330                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3331                 if (_ptr_ts) {
3332                         NDR_PULL_ALLOC(ndr, r->ts);
3333                 } else {
3334                         r->ts = NULL;
3335                 }
3336                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3337         }
3338         if (ndr_flags & NDR_BUFFERS) {
3339                 if (r->ts) {
3340                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3341                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3342                         {
3343                                 struct ndr_pull *_ndr_ts;
3344                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3345                                 {
3346                                         struct ndr_pull *_ndr_ts_compressed;
3347                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3348                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3349                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3350                                 }
3351                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3352                         }
3353                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3354                 }
3355         }
3356         return NDR_ERR_SUCCESS;
3357 }
3358
3359 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr1 *r)
3360 {
3361         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr1");
3362         ndr->depth++;
3363         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3364         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3365         ndr_print_ptr(ndr, "ts", r->ts);
3366         ndr->depth++;
3367         if (r->ts) {
3368                 ndr_print_drsuapi_DsGetNCChangesCtr1TS(ndr, "ts", r->ts);
3369         }
3370         ndr->depth--;
3371         ndr->depth--;
3372 }
3373
3374 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3375 {
3376         uint32_t _ptr_ts;
3377         TALLOC_CTX *_mem_save_ts_0;
3378         if (ndr_flags & NDR_SCALARS) {
3379                 NDR_CHECK(ndr_pull_align(ndr, 5));
3380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->decompressed_length));
3381                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->compressed_length));
3382                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ts));
3383                 if (_ptr_ts) {
3384                         NDR_PULL_ALLOC(ndr, r->ts);
3385                 } else {
3386                         r->ts = NULL;
3387                 }
3388                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3389         }
3390         if (ndr_flags & NDR_BUFFERS) {
3391                 if (r->ts) {
3392                         _mem_save_ts_0 = NDR_PULL_GET_MEM_CTX(ndr);
3393                         NDR_PULL_SET_MEM_CTX(ndr, r->ts, 0);
3394                         {
3395                                 struct ndr_pull *_ndr_ts;
3396                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_ts, 4, r->compressed_length));
3397                                 {
3398                                         struct ndr_pull *_ndr_ts_compressed;
3399                                         NDR_CHECK(ndr_pull_compression_start(_ndr_ts, &_ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3400                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6TS(_ndr_ts_compressed, NDR_SCALARS|NDR_BUFFERS, r->ts));
3401                                         NDR_CHECK(ndr_pull_compression_end(_ndr_ts, _ndr_ts_compressed, NDR_COMPRESSION_XPRESS, r->decompressed_length));
3402                                 }
3403                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_ts, 4, r->compressed_length));
3404                         }
3405                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ts_0, 0);
3406                 }
3407         }
3408         return NDR_ERR_SUCCESS;
3409 }
3410
3411 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesXPRESSCtr6 *r)
3412 {
3413         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesXPRESSCtr6");
3414         ndr->depth++;
3415         ndr_print_uint32(ndr, "decompressed_length", r->decompressed_length);
3416         ndr_print_uint32(ndr, "compressed_length", r->compressed_length);
3417         ndr_print_ptr(ndr, "ts", r->ts);
3418         ndr->depth++;
3419         if (r->ts) {
3420                 ndr_print_drsuapi_DsGetNCChangesCtr6TS(ndr, "ts", r->ts);
3421         }
3422         ndr->depth--;
3423         ndr->depth--;
3424 }
3425
3426 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressionType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType r)
3427 {
3428         NDR_CHECK(ndr_push_enum_uint16(ndr, NDR_SCALARS, r));
3429         return NDR_ERR_SUCCESS;
3430 }
3431
3432 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressionType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsGetNCChangesCompressionType *r)
3433 {
3434         uint16_t v;
3435         NDR_CHECK(ndr_pull_enum_uint16(ndr, NDR_SCALARS, &v));
3436         *r = v;
3437         return NDR_ERR_SUCCESS;
3438 }
3439
3440 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressionType(struct ndr_print *ndr, const char *name, enum drsuapi_DsGetNCChangesCompressionType r)
3441 {
3442         const char *val = NULL;
3443
3444         switch (r) {
3445                 case DRSUAPI_COMPRESSION_TYPE_MSZIP: val = "DRSUAPI_COMPRESSION_TYPE_MSZIP"; break;
3446                 case DRSUAPI_COMPRESSION_TYPE_XPRESS: val = "DRSUAPI_COMPRESSION_TYPE_XPRESS"; break;
3447         }
3448         ndr_print_enum(ndr, name, "ENUM", val, r);
3449 }
3450
3451 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3452 {
3453         {
3454                 uint32_t _flags_save_UNION = ndr->flags;
3455                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3456                 if (ndr_flags & NDR_SCALARS) {
3457                         int level = ndr_push_get_switch_value(ndr, r);
3458                         NDR_CHECK(ndr_push_union_align(ndr, 5));
3459                         switch (level) {
3460                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3461                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3462                                 break; }
3463
3464                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3465                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3466                                 break; }
3467
3468                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3469                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3470                                 break; }
3471
3472                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3473                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3474                                 break; }
3475
3476                                 default:
3477                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3478                         }
3479                 }
3480                 if (ndr_flags & NDR_BUFFERS) {
3481                         int level = ndr_push_get_switch_value(ndr, r);
3482                         switch (level) {
3483                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3484                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3485                                 break;
3486
3487                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3488                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3489                                 break;
3490
3491                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3492                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3493                                 break;
3494
3495                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3496                                         NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3497                                 break;
3498
3499                                 default:
3500                                         return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3501                         }
3502                 }
3503                 ndr->flags = _flags_save_UNION;
3504         }
3505         return NDR_ERR_SUCCESS;
3506 }
3507
3508 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCompressedCtr *r)
3509 {
3510         int level;
3511         {
3512                 uint32_t _flags_save_UNION = ndr->flags;
3513                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3514                 level = ndr_pull_get_switch_value(ndr, r);
3515                 if (ndr_flags & NDR_SCALARS) {
3516                         NDR_CHECK(ndr_pull_union_align(ndr, 5));
3517                         switch (level) {
3518                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3519                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3520                                 break; }
3521
3522                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16): {
3523                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_SCALARS, &r->mszip6));
3524                                 break; }
3525
3526                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3527                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_SCALARS, &r->xpress1));
3528                                 break; }
3529
3530                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16): {
3531                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_SCALARS, &r->xpress6));
3532                                 break; }
3533
3534                                 default:
3535                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3536                         }
3537                 }
3538                 if (ndr_flags & NDR_BUFFERS) {
3539                         switch (level) {
3540                                 case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3541                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3542                                 break;
3543
3544                                 case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3545                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, NDR_BUFFERS, &r->mszip6));
3546                                 break;
3547
3548                                 case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3549                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, NDR_BUFFERS, &r->xpress1));
3550                                 break;
3551
3552                                 case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3553                                         NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, NDR_BUFFERS, &r->xpress6));
3554                                 break;
3555
3556                                 default:
3557                                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3558                         }
3559                 }
3560                 ndr->flags = _flags_save_UNION;
3561         }
3562         return NDR_ERR_SUCCESS;
3563 }
3564
3565 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCompressedCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCompressedCtr *r)
3566 {
3567         int level;
3568         {
3569                 uint32_t _flags_save_UNION = ndr->flags;
3570                 ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
3571                 level = ndr_print_get_switch_value(ndr, r);
3572                 ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCompressedCtr");
3573                 switch (level) {
3574                         case 1|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3575                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3576                         break;
3577
3578                         case 6|(DRSUAPI_COMPRESSION_TYPE_MSZIP<<16):
3579                                 ndr_print_drsuapi_DsGetNCChangesMSZIPCtr6(ndr, "mszip6", &r->mszip6);
3580                         break;
3581
3582                         case 1|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3583                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr1(ndr, "xpress1", &r->xpress1);
3584                         break;
3585
3586                         case 6|(DRSUAPI_COMPRESSION_TYPE_XPRESS<<16):
3587                                 ndr_print_drsuapi_DsGetNCChangesXPRESSCtr6(ndr, "xpress6", &r->xpress6);
3588                         break;
3589
3590                         default:
3591                                 ndr_print_bad_level(ndr, name, level);
3592                 }
3593                 ndr->flags = _flags_save_UNION;
3594         }
3595 }
3596
3597 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr2 *r)
3598 {
3599         if (ndr_flags & NDR_SCALARS) {
3600                 NDR_CHECK(ndr_push_align(ndr, 5));
3601                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3602                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3603         }
3604         if (ndr_flags & NDR_BUFFERS) {
3605                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3606         }
3607         return NDR_ERR_SUCCESS;
3608 }
3609
3610 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr2 *r)
3611 {
3612         if (ndr_flags & NDR_SCALARS) {
3613                 NDR_CHECK(ndr_pull_align(ndr, 5));
3614                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_SCALARS, &r->mszip1));
3615                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3616         }
3617         if (ndr_flags & NDR_BUFFERS) {
3618                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, NDR_BUFFERS, &r->mszip1));
3619         }
3620         return NDR_ERR_SUCCESS;
3621 }
3622
3623 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr2 *r)
3624 {
3625         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr2");
3626         ndr->depth++;
3627         ndr_print_drsuapi_DsGetNCChangesMSZIPCtr1(ndr, "mszip1", &r->mszip1);
3628         ndr->depth--;
3629 }
3630
3631 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr7(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNCChangesCtr7 *r)
3632 {
3633         if (ndr_flags & NDR_SCALARS) {
3634                 NDR_CHECK(ndr_push_align(ndr, 5));
3635                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
3636                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, r->type));
3637                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3638                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3639                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3640         }
3641         if (ndr_flags & NDR_BUFFERS) {
3642                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3643         }
3644         return NDR_ERR_SUCCESS;
3645 }
3646
3647 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr7(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNCChangesCtr7 *r)
3648 {
3649         if (ndr_flags & NDR_SCALARS) {
3650                 NDR_CHECK(ndr_pull_align(ndr, 5));
3651                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
3652                 if (r->level < 0 || r->level > 6) {
3653                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3654                 }
3655                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressionType(ndr, NDR_SCALARS, &r->type));
3656                 if (r->type < 2 || r->type > 3) {
3657                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3658                 }
3659                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16)));
3660                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_SCALARS, &r->ctr));
3661                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3662         }
3663         if (ndr_flags & NDR_BUFFERS) {
3664                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCompressedCtr(ndr, NDR_BUFFERS, &r->ctr));
3665         }
3666         return NDR_ERR_SUCCESS;
3667 }
3668
3669 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr7(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNCChangesCtr7 *r)
3670 {
3671         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChangesCtr7");
3672         ndr->depth++;
3673         ndr_print_int32(ndr, "level", r->level);
3674         ndr_print_drsuapi_DsGetNCChangesCompressionType(ndr, "type", r->type);
3675         ndr_print_set_switch_value(ndr, &r->ctr, r->level | (r->type << 16));
3676         ndr_print_drsuapi_DsGetNCChangesCompressedCtr(ndr, "ctr", &r->ctr);
3677         ndr->depth--;
3678 }
3679
3680 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChangesCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNCChangesCtr *r)
3681 {
3682         if (ndr_flags & NDR_SCALARS) {
3683                 int level = ndr_push_get_switch_value(ndr, r);
3684                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3685                 NDR_CHECK(ndr_push_union_align(ndr, 8));
3686                 switch (level) {
3687                         case 1: {
3688                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3689                         break; }
3690
3691                         case 2: {
3692                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3693                         break; }
3694
3695                         case 6: {
3696                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3697                         break; }
3698
3699                         case 7: {
3700                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3701                         break; }
3702
3703                         default:
3704                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3705                 }
3706         }
3707         if (ndr_flags & NDR_BUFFERS) {
3708                 int level = ndr_push_get_switch_value(ndr, r);
3709                 switch (level) {
3710                         case 1:
3711                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3712                         break;
3713
3714                         case 2:
3715                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3716                         break;
3717
3718                         case 6:
3719                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3720                         break;
3721
3722                         case 7:
3723                                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3724                         break;
3725
3726                         default:
3727                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3728                 }
3729         }
3730         return NDR_ERR_SUCCESS;
3731 }
3732
3733 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChangesCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNCChangesCtr *r)
3734 {
3735         int level;
3736         int32_t _level;
3737         level = ndr_pull_get_switch_value(ndr, r);
3738         if (ndr_flags & NDR_SCALARS) {
3739                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3740                 if (_level != level) {
3741                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3742                 }
3743                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
3744                 switch (level) {
3745                         case 1: {
3746                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_SCALARS, &r->ctr1));
3747                         break; }
3748
3749                         case 2: {
3750                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_SCALARS, &r->ctr2));
3751                         break; }
3752
3753                         case 6: {
3754                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_SCALARS, &r->ctr6));
3755                         break; }
3756
3757                         case 7: {
3758                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_SCALARS, &r->ctr7));
3759                         break; }
3760
3761                         default:
3762                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3763                 }
3764         }
3765         if (ndr_flags & NDR_BUFFERS) {
3766                 switch (level) {
3767                         case 1:
3768                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr1(ndr, NDR_BUFFERS, &r->ctr1));
3769                         break;
3770
3771                         case 2:
3772                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr2(ndr, NDR_BUFFERS, &r->ctr2));
3773                         break;
3774
3775                         case 6:
3776                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr6(ndr, NDR_BUFFERS, &r->ctr6));
3777                         break;
3778
3779                         case 7:
3780                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr7(ndr, NDR_BUFFERS, &r->ctr7));
3781                         break;
3782
3783                         default:
3784                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3785                 }
3786         }
3787         return NDR_ERR_SUCCESS;
3788 }
3789
3790 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChangesCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNCChangesCtr *r)
3791 {
3792         int level;
3793         level = ndr_print_get_switch_value(ndr, r);
3794         ndr_print_union(ndr, name, level, "drsuapi_DsGetNCChangesCtr");
3795         switch (level) {
3796                 case 1:
3797                         ndr_print_drsuapi_DsGetNCChangesCtr1(ndr, "ctr1", &r->ctr1);
3798                 break;
3799
3800                 case 2:
3801                         ndr_print_drsuapi_DsGetNCChangesCtr2(ndr, "ctr2", &r->ctr2);
3802                 break;
3803
3804                 case 6:
3805                         ndr_print_drsuapi_DsGetNCChangesCtr6(ndr, "ctr6", &r->ctr6);
3806                 break;
3807
3808                 case 7:
3809                         ndr_print_drsuapi_DsGetNCChangesCtr7(ndr, "ctr7", &r->ctr7);
3810                 break;
3811
3812                 default:
3813                         ndr_print_bad_level(ndr, name, level);
3814         }
3815 }
3816
3817 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3818 {
3819         if (ndr_flags & NDR_SCALARS) {
3820                 NDR_CHECK(ndr_push_align(ndr, 5));
3821                 if (r->naming_context == NULL) {
3822                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3823                 }
3824                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3825                 if (r->dest_dsa_dns_name == NULL) {
3826                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3827                 }
3828                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3829                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3830                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
3831                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3832         }
3833         if (ndr_flags & NDR_BUFFERS) {
3834                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3835                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3836                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3837                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dest_dsa_dns_name, CH_DOS)));
3838                 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));
3839         }
3840         return NDR_ERR_SUCCESS;
3841 }
3842
3843 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3844 {
3845         uint32_t _ptr_naming_context;
3846         TALLOC_CTX *_mem_save_naming_context_0;
3847         uint32_t _ptr_dest_dsa_dns_name;
3848         if (ndr_flags & NDR_SCALARS) {
3849                 NDR_CHECK(ndr_pull_align(ndr, 5));
3850                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
3851                 if (_ptr_naming_context) {
3852                         NDR_PULL_ALLOC(ndr, r->naming_context);
3853                 } else {
3854                         r->naming_context = NULL;
3855                 }
3856                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_dest_dsa_dns_name));
3857                 if (_ptr_dest_dsa_dns_name) {
3858                         NDR_PULL_ALLOC(ndr, r->dest_dsa_dns_name);
3859                 } else {
3860                         r->dest_dsa_dns_name = NULL;
3861                 }
3862                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dest_dsa_guid));
3863                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
3864                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
3865         }
3866         if (ndr_flags & NDR_BUFFERS) {
3867                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
3868                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
3869                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3870                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
3871                 NDR_CHECK(ndr_pull_array_size(ndr, &r->dest_dsa_dns_name));
3872                 NDR_CHECK(ndr_pull_array_length(ndr, &r->dest_dsa_dns_name));
3873                 if (ndr_get_array_length(ndr, &r->dest_dsa_dns_name) > ndr_get_array_size(ndr, &r->dest_dsa_dns_name)) {
3874                         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));
3875                 }
3876                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dest_dsa_dns_name), sizeof(uint8_t)));
3877                 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));
3878         }
3879         return NDR_ERR_SUCCESS;
3880 }
3881
3882 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r)
3883 {
3884         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefsRequest1");
3885         ndr->depth++;
3886         ndr_print_ptr(ndr, "naming_context", r->naming_context);
3887         ndr->depth++;
3888         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
3889         ndr->depth--;
3890         ndr_print_ptr(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3891         ndr->depth++;
3892         ndr_print_string(ndr, "dest_dsa_dns_name", r->dest_dsa_dns_name);
3893         ndr->depth--;
3894         ndr_print_GUID(ndr, "dest_dsa_guid", &r->dest_dsa_guid);
3895         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
3896         ndr->depth--;
3897 }
3898
3899 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3900 {
3901         if (ndr_flags & NDR_SCALARS) {
3902                 int level = ndr_push_get_switch_value(ndr, r);
3903                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
3904                 NDR_CHECK(ndr_push_union_align(ndr, 5));
3905                 switch (level) {
3906                         case 1: {
3907                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3908                         break; }
3909
3910                         default:
3911                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3912                 }
3913         }
3914         if (ndr_flags & NDR_BUFFERS) {
3915                 int level = ndr_push_get_switch_value(ndr, r);
3916                 switch (level) {
3917                         case 1:
3918                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3919                         break;
3920
3921                         default:
3922                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3923                 }
3924         }
3925         return NDR_ERR_SUCCESS;
3926 }
3927
3928 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaUpdateRefsRequest *r)
3929 {
3930         int level;
3931         int32_t _level;
3932         level = ndr_pull_get_switch_value(ndr, r);
3933         if (ndr_flags & NDR_SCALARS) {
3934                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
3935                 if (_level != level) {
3936                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
3937                 }
3938                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
3939                 switch (level) {
3940                         case 1: {
3941                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_SCALARS, &r->req1));
3942                         break; }
3943
3944                         default:
3945                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3946                 }
3947         }
3948         if (ndr_flags & NDR_BUFFERS) {
3949                 switch (level) {
3950                         case 1:
3951                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest1(ndr, NDR_BUFFERS, &r->req1));
3952                         break;
3953
3954                         default:
3955                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
3956                 }
3957         }
3958         return NDR_ERR_SUCCESS;
3959 }
3960
3961 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r)
3962 {
3963         int level;
3964         level = ndr_print_get_switch_value(ndr, r);
3965         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaUpdateRefsRequest");
3966         switch (level) {
3967                 case 1:
3968                         ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(ndr, "req1", &r->req1);
3969                 break;
3970
3971                 default:
3972                         ndr_print_bad_level(ndr, name, level);
3973         }
3974 }
3975
3976 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest1 *r)
3977 {
3978         if (ndr_flags & NDR_SCALARS) {
3979                 NDR_CHECK(ndr_push_align(ndr, 5));
3980                 if (r->naming_context == NULL) {
3981                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
3982                 }
3983                 NDR_CHECK(ndr_push_ref_ptr(ndr));
3984                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
3985                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
3986                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
3987                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
3988         }
3989         if (ndr_flags & NDR_BUFFERS) {
3990                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
3991                 if (r->source_dsa_address) {
3992                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3993                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
3994                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
3995                         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));
3996                 }
3997         }
3998         return NDR_ERR_SUCCESS;
3999 }
4000
4001 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest1 *r)
4002 {
4003         uint32_t _ptr_naming_context;
4004         TALLOC_CTX *_mem_save_naming_context_0;
4005         uint32_t _ptr_source_dsa_address;
4006         TALLOC_CTX *_mem_save_source_dsa_address_0;
4007         if (ndr_flags & NDR_SCALARS) {
4008                 NDR_CHECK(ndr_pull_align(ndr, 5));
4009                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4010                 if (_ptr_naming_context) {
4011                         NDR_PULL_ALLOC(ndr, r->naming_context);
4012                 } else {
4013                         r->naming_context = NULL;
4014                 }
4015                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4016                 if (_ptr_source_dsa_address) {
4017                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4018                 } else {
4019                         r->source_dsa_address = NULL;
4020                 }
4021                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4022                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4023                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4024         }
4025         if (ndr_flags & NDR_BUFFERS) {
4026                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4027                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4028                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4029                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4030                 if (r->source_dsa_address) {
4031                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4032                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4033                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4034                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4035                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4036                                 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));
4037                         }
4038                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4039                         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));
4040                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4041                 }
4042         }
4043         return NDR_ERR_SUCCESS;
4044 }
4045
4046 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest1 *r)
4047 {
4048         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest1");
4049         ndr->depth++;
4050         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4051         ndr->depth++;
4052         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4053         ndr->depth--;
4054         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4055         ndr->depth++;
4056         if (r->source_dsa_address) {
4057                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4058         }
4059         ndr->depth--;
4060         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4061         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4062         ndr->depth--;
4063 }
4064
4065 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest2 *r)
4066 {
4067         if (ndr_flags & NDR_SCALARS) {
4068                 NDR_CHECK(ndr_push_align(ndr, 5));
4069                 if (r->naming_context == NULL) {
4070                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4071                 }
4072                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4073                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_dn));
4074                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_dn));
4075                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4076                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4077                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4078                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4079         }
4080         if (ndr_flags & NDR_BUFFERS) {
4081                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4082                 if (r->source_dsa_dn) {
4083                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4084                 }
4085                 if (r->transport_dn) {
4086                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4087                 }
4088                 if (r->source_dsa_address) {
4089                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4090                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4091                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4092                         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));
4093                 }
4094         }
4095         return NDR_ERR_SUCCESS;
4096 }
4097
4098 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest2 *r)
4099 {
4100         uint32_t _ptr_naming_context;
4101         TALLOC_CTX *_mem_save_naming_context_0;
4102         uint32_t _ptr_source_dsa_dn;
4103         TALLOC_CTX *_mem_save_source_dsa_dn_0;
4104         uint32_t _ptr_transport_dn;
4105         TALLOC_CTX *_mem_save_transport_dn_0;
4106         uint32_t _ptr_source_dsa_address;
4107         TALLOC_CTX *_mem_save_source_dsa_address_0;
4108         if (ndr_flags & NDR_SCALARS) {
4109                 NDR_CHECK(ndr_pull_align(ndr, 5));
4110                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4111                 if (_ptr_naming_context) {
4112                         NDR_PULL_ALLOC(ndr, r->naming_context);
4113                 } else {
4114                         r->naming_context = NULL;
4115                 }
4116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_dn));
4117                 if (_ptr_source_dsa_dn) {
4118                         NDR_PULL_ALLOC(ndr, r->source_dsa_dn);
4119                 } else {
4120                         r->source_dsa_dn = NULL;
4121                 }
4122                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_dn));
4123                 if (_ptr_transport_dn) {
4124                         NDR_PULL_ALLOC(ndr, r->transport_dn);
4125                 } else {
4126                         r->transport_dn = NULL;
4127                 }
4128                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4129                 if (_ptr_source_dsa_address) {
4130                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4131                 } else {
4132                         r->source_dsa_address = NULL;
4133                 }
4134                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4135                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4136                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4137         }
4138         if (ndr_flags & NDR_BUFFERS) {
4139                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4140                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4141                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4142                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4143                 if (r->source_dsa_dn) {
4144                         _mem_save_source_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4145                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_dn, 0);
4146                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn));
4147                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_dn_0, 0);
4148                 }
4149                 if (r->transport_dn) {
4150                         _mem_save_transport_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
4151                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_dn, 0);
4152                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn));
4153                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_dn_0, 0);
4154                 }
4155                 if (r->source_dsa_address) {
4156                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4157                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4158                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4159                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4160                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4161                                 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));
4162                         }
4163                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4164                         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));
4165                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4166                 }
4167         }
4168         return NDR_ERR_SUCCESS;
4169 }
4170
4171 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest2 *r)
4172 {
4173         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest2");
4174         ndr->depth++;
4175         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4176         ndr->depth++;
4177         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4178         ndr->depth--;
4179         ndr_print_ptr(ndr, "source_dsa_dn", r->source_dsa_dn);
4180         ndr->depth++;
4181         if (r->source_dsa_dn) {
4182                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "source_dsa_dn", r->source_dsa_dn);
4183         }
4184         ndr->depth--;
4185         ndr_print_ptr(ndr, "transport_dn", r->transport_dn);
4186         ndr->depth++;
4187         if (r->transport_dn) {
4188                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "transport_dn", r->transport_dn);
4189         }
4190         ndr->depth--;
4191         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4192         ndr->depth++;
4193         if (r->source_dsa_address) {
4194                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4195         }
4196         ndr->depth--;
4197         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4198         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4199         ndr->depth--;
4200 }
4201
4202 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaAddRequest *r)
4203 {
4204         if (ndr_flags & NDR_SCALARS) {
4205                 int level = ndr_push_get_switch_value(ndr, r);
4206                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4207                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4208                 switch (level) {
4209                         case 1: {
4210                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4211                         break; }
4212
4213                         case 2: {
4214                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4215                         break; }
4216
4217                         default:
4218                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4219                 }
4220         }
4221         if (ndr_flags & NDR_BUFFERS) {
4222                 int level = ndr_push_get_switch_value(ndr, r);
4223                 switch (level) {
4224                         case 1:
4225                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4226                         break;
4227
4228                         case 2:
4229                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4230                         break;
4231
4232                         default:
4233                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4234                 }
4235         }
4236         return NDR_ERR_SUCCESS;
4237 }
4238
4239 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaAddRequest *r)
4240 {
4241         int level;
4242         int32_t _level;
4243         level = ndr_pull_get_switch_value(ndr, r);
4244         if (ndr_flags & NDR_SCALARS) {
4245                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4246                 if (_level != level) {
4247                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4248                 }
4249                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4250                 switch (level) {
4251                         case 1: {
4252                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1));
4253                         break; }
4254
4255                         case 2: {
4256                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2));
4257                         break; }
4258
4259                         default:
4260                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4261                 }
4262         }
4263         if (ndr_flags & NDR_BUFFERS) {
4264                 switch (level) {
4265                         case 1:
4266                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1));
4267                         break;
4268
4269                         case 2:
4270                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2));
4271                         break;
4272
4273                         default:
4274                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4275                 }
4276         }
4277         return NDR_ERR_SUCCESS;
4278 }
4279
4280 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaAddRequest *r)
4281 {
4282         int level;
4283         level = ndr_print_get_switch_value(ndr, r);
4284         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaAddRequest");
4285         switch (level) {
4286                 case 1:
4287                         ndr_print_drsuapi_DsReplicaAddRequest1(ndr, "req1", &r->req1);
4288                 break;
4289
4290                 case 2:
4291                         ndr_print_drsuapi_DsReplicaAddRequest2(ndr, "req2", &r->req2);
4292                 break;
4293
4294                 default:
4295                         ndr_print_bad_level(ndr, name, level);
4296         }
4297 }
4298
4299 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaDelRequest1 *r)
4300 {
4301         if (ndr_flags & NDR_SCALARS) {
4302                 NDR_CHECK(ndr_push_align(ndr, 5));
4303                 if (r->naming_context == NULL) {
4304                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4305                 }
4306                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4307                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
4308                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4309                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4310         }
4311         if (ndr_flags & NDR_BUFFERS) {
4312                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4313                 if (r->source_dsa_address) {
4314                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4315                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4316                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
4317                         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));
4318                 }
4319         }
4320         return NDR_ERR_SUCCESS;
4321 }
4322
4323 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaDelRequest1 *r)
4324 {
4325         uint32_t _ptr_naming_context;
4326         TALLOC_CTX *_mem_save_naming_context_0;
4327         uint32_t _ptr_source_dsa_address;
4328         TALLOC_CTX *_mem_save_source_dsa_address_0;
4329         if (ndr_flags & NDR_SCALARS) {
4330                 NDR_CHECK(ndr_pull_align(ndr, 5));
4331                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4332                 if (_ptr_naming_context) {
4333                         NDR_PULL_ALLOC(ndr, r->naming_context);
4334                 } else {
4335                         r->naming_context = NULL;
4336                 }
4337                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
4338                 if (_ptr_source_dsa_address) {
4339                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
4340                 } else {
4341                         r->source_dsa_address = NULL;
4342                 }
4343                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4344                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4345         }
4346         if (ndr_flags & NDR_BUFFERS) {
4347                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4348                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4349                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4350                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4351                 if (r->source_dsa_address) {
4352                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4353                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
4354                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
4355                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
4356                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
4357                                 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));
4358                         }
4359                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
4360                         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));
4361                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
4362                 }
4363         }
4364         return NDR_ERR_SUCCESS;
4365 }
4366
4367 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaDelRequest1 *r)
4368 {
4369         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDelRequest1");
4370         ndr->depth++;
4371         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4372         ndr->depth++;
4373         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4374         ndr->depth--;
4375         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
4376         ndr->depth++;
4377         if (r->source_dsa_address) {
4378                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
4379         }
4380         ndr->depth--;
4381         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4382         ndr->depth--;
4383 }
4384
4385 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaDelRequest *r)
4386 {
4387         if (ndr_flags & NDR_SCALARS) {
4388                 int level = ndr_push_get_switch_value(ndr, r);
4389                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4390                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4391                 switch (level) {
4392                         case 1: {
4393                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4394                         break; }
4395
4396                         default:
4397                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4398                 }
4399         }
4400         if (ndr_flags & NDR_BUFFERS) {
4401                 int level = ndr_push_get_switch_value(ndr, r);
4402                 switch (level) {
4403                         case 1:
4404                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4405                         break;
4406
4407                         default:
4408                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4409                 }
4410         }
4411         return NDR_ERR_SUCCESS;
4412 }
4413
4414 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaDelRequest *r)
4415 {
4416         int level;
4417         int32_t _level;
4418         level = ndr_pull_get_switch_value(ndr, r);
4419         if (ndr_flags & NDR_SCALARS) {
4420                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4421                 if (_level != level) {
4422                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4423                 }
4424                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4425                 switch (level) {
4426                         case 1: {
4427                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1));
4428                         break; }
4429
4430                         default:
4431                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4432                 }
4433         }
4434         if (ndr_flags & NDR_BUFFERS) {
4435                 switch (level) {
4436                         case 1:
4437                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1));
4438                         break;
4439
4440                         default:
4441                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4442                 }
4443         }
4444         return NDR_ERR_SUCCESS;
4445 }
4446
4447 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaDelRequest *r)
4448 {
4449         int level;
4450         level = ndr_print_get_switch_value(ndr, r);
4451         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaDelRequest");
4452         switch (level) {
4453                 case 1:
4454                         ndr_print_drsuapi_DsReplicaDelRequest1(ndr, "req1", &r->req1);
4455                 break;
4456
4457                 default:
4458                         ndr_print_bad_level(ndr, name, level);
4459         }
4460 }
4461
4462 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaModRequest1 *r)
4463 {
4464         if (ndr_flags & NDR_SCALARS) {
4465                 NDR_CHECK(ndr_push_align(ndr, 5));
4466                 if (r->naming_context == NULL) {
4467                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
4468                 }
4469                 NDR_CHECK(ndr_push_ref_ptr(ndr));
4470                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dra));
4471                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dra_address));
4472                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4473                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->replica_flags));
4474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->modify_fields));
4475                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
4476                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4477         }
4478         if (ndr_flags & NDR_BUFFERS) {
4479                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4480                 if (r->source_dra_address) {
4481                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4482                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
4483                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16)));
4484                         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));
4485                 }
4486         }
4487         return NDR_ERR_SUCCESS;
4488 }
4489
4490 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaModRequest1 *r)
4491 {
4492         uint32_t _ptr_naming_context;
4493         TALLOC_CTX *_mem_save_naming_context_0;
4494         uint32_t _ptr_source_dra_address;
4495         TALLOC_CTX *_mem_save_source_dra_address_0;
4496         if (ndr_flags & NDR_SCALARS) {
4497                 NDR_CHECK(ndr_pull_align(ndr, 5));
4498                 NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context));
4499                 if (_ptr_naming_context) {
4500                         NDR_PULL_ALLOC(ndr, r->naming_context);
4501                 } else {
4502                         r->naming_context = NULL;
4503                 }
4504                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dra));
4505                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dra_address));
4506                 if (_ptr_source_dra_address) {
4507                         NDR_PULL_ALLOC(ndr, r->source_dra_address);
4508                 } else {
4509                         r->source_dra_address = NULL;
4510                 }
4511                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84));
4512                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->replica_flags));
4513                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->modify_fields));
4514                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
4515                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4516         }
4517         if (ndr_flags & NDR_BUFFERS) {
4518                 _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr);
4519                 NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0);
4520                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context));
4521                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0);
4522                 if (r->source_dra_address) {
4523                         _mem_save_source_dra_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
4524                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dra_address, 0);
4525                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dra_address));
4526                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dra_address));
4527                         if (ndr_get_array_length(ndr, &r->source_dra_address) > ndr_get_array_size(ndr, &r->source_dra_address)) {
4528                                 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));
4529                         }
4530                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t)));
4531                         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));
4532                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dra_address_0, 0);
4533                 }
4534         }
4535         return NDR_ERR_SUCCESS;
4536 }
4537
4538 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaModRequest1 *r)
4539 {
4540         ndr_print_struct(ndr, name, "drsuapi_DsReplicaModRequest1");
4541         ndr->depth++;
4542         ndr_print_ptr(ndr, "naming_context", r->naming_context);
4543         ndr->depth++;
4544         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context);
4545         ndr->depth--;
4546         ndr_print_GUID(ndr, "source_dra", &r->source_dra);
4547         ndr_print_ptr(ndr, "source_dra_address", r->source_dra_address);
4548         ndr->depth++;
4549         if (r->source_dra_address) {
4550                 ndr_print_string(ndr, "source_dra_address", r->source_dra_address);
4551         }
4552         ndr->depth--;
4553         ndr_print_array_uint8(ndr, "schedule", r->schedule, 84);
4554         ndr_print_uint32(ndr, "replica_flags", r->replica_flags);
4555         ndr_print_uint32(ndr, "modify_fields", r->modify_fields);
4556         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
4557         ndr->depth--;
4558 }
4559
4560 static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaModRequest *r)
4561 {
4562         if (ndr_flags & NDR_SCALARS) {
4563                 int level = ndr_push_get_switch_value(ndr, r);
4564                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4565                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4566                 switch (level) {
4567                         case 1: {
4568                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4569                         break; }
4570
4571                         default:
4572                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4573                 }
4574         }
4575         if (ndr_flags & NDR_BUFFERS) {
4576                 int level = ndr_push_get_switch_value(ndr, r);
4577                 switch (level) {
4578                         case 1:
4579                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4580                         break;
4581
4582                         default:
4583                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4584                 }
4585         }
4586         return NDR_ERR_SUCCESS;
4587 }
4588
4589 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaModRequest *r)
4590 {
4591         int level;
4592         int32_t _level;
4593         level = ndr_pull_get_switch_value(ndr, r);
4594         if (ndr_flags & NDR_SCALARS) {
4595                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4596                 if (_level != level) {
4597                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4598                 }
4599                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4600                 switch (level) {
4601                         case 1: {
4602                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1));
4603                         break; }
4604
4605                         default:
4606                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4607                 }
4608         }
4609         if (ndr_flags & NDR_BUFFERS) {
4610                 switch (level) {
4611                         case 1:
4612                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1));
4613                         break;
4614
4615                         default:
4616                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4617                 }
4618         }
4619         return NDR_ERR_SUCCESS;
4620 }
4621
4622 _PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaModRequest *r)
4623 {
4624         int level;
4625         level = ndr_print_get_switch_value(ndr, r);
4626         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaModRequest");
4627         switch (level) {
4628                 case 1:
4629                         ndr_print_drsuapi_DsReplicaModRequest1(ndr, "req1", &r->req1);
4630                 break;
4631
4632                 default:
4633                         ndr_print_bad_level(ndr, name, level);
4634         }
4635 }
4636
4637 static enum ndr_err_code ndr_push_drsuapi_DsMembershipType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsMembershipType r)
4638 {
4639         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
4640         return NDR_ERR_SUCCESS;
4641 }
4642
4643 static enum ndr_err_code ndr_pull_drsuapi_DsMembershipType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsMembershipType *r)
4644 {
4645         uint32_t v;
4646         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
4647         *r = v;
4648         return NDR_ERR_SUCCESS;
4649 }
4650
4651 _PUBLIC_ void ndr_print_drsuapi_DsMembershipType(struct ndr_print *ndr, const char *name, enum drsuapi_DsMembershipType r)
4652 {
4653         const char *val = NULL;
4654
4655         switch (r) {
4656                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_AND_DOMAIN_GROUPS"; break;
4657                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS"; break;
4658                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS"; break;
4659                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_LOCAL_GROUPS2"; break;
4660                 case DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_UNIVERSAL_GROUPS"; break;
4661                 case DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_GROUPMEMBERS"; break;
4662                 case DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2: val = "DRSUAPI_DS_MEMBERSHIP_TYPE_DOMAIN_GROUPS2"; break;
4663         }
4664         ndr_print_enum(ndr, name, "ENUM", val, r);
4665 }
4666
4667 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsCtr1 *r)
4668 {
4669         uint32_t cntr_info_array_1;
4670         uint32_t cntr_group_attrs_1;
4671         uint32_t cntr_sids_1;
4672         if (ndr_flags & NDR_SCALARS) {
4673                 NDR_CHECK(ndr_push_align(ndr, 5));
4674                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
4675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_memberships));
4676                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_sids));
4677                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->group_attrs));
4679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids));
4680                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4681         }
4682         if (ndr_flags & NDR_BUFFERS) {
4683                 if (r->info_array) {
4684                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4685                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4686                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
4687                         }
4688                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4689                                 if (r->info_array[cntr_info_array_1]) {
4690                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4691                                 }
4692                         }
4693                 }
4694                 if (r->group_attrs) {
4695                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_memberships));
4696                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4697                                 NDR_CHECK(ndr_push_samr_GroupAttrs(ndr, NDR_SCALARS, r->group_attrs[cntr_group_attrs_1]));
4698                         }
4699                 }
4700                 if (r->sids) {
4701                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_sids));
4702                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4703                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sids[cntr_sids_1]));
4704                         }
4705                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4706                                 if (r->sids[cntr_sids_1]) {
4707                                         NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4708                                 }
4709                         }
4710                 }
4711         }
4712         return NDR_ERR_SUCCESS;
4713 }
4714
4715 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsCtr1 *r)
4716 {
4717         uint32_t _ptr_info_array;
4718         uint32_t cntr_info_array_1;
4719         TALLOC_CTX *_mem_save_info_array_0;
4720         TALLOC_CTX *_mem_save_info_array_1;
4721         TALLOC_CTX *_mem_save_info_array_2;
4722         uint32_t _ptr_group_attrs;
4723         uint32_t cntr_group_attrs_1;
4724         TALLOC_CTX *_mem_save_group_attrs_0;
4725         TALLOC_CTX *_mem_save_group_attrs_1;
4726         uint32_t _ptr_sids;
4727         uint32_t cntr_sids_1;
4728         TALLOC_CTX *_mem_save_sids_0;
4729         TALLOC_CTX *_mem_save_sids_1;
4730         TALLOC_CTX *_mem_save_sids_2;
4731         if (ndr_flags & NDR_SCALARS) {
4732                 NDR_CHECK(ndr_pull_align(ndr, 5));
4733                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
4734                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_memberships));
4735                 if (r->num_memberships > 10000) {
4736                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4737                 }
4738                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_sids));
4739                 if (r->num_sids > 10000) {
4740                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4741                 }
4742                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4743                 if (_ptr_info_array) {
4744                         NDR_PULL_ALLOC(ndr, r->info_array);
4745                 } else {
4746                         r->info_array = NULL;
4747                 }
4748                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_group_attrs));
4749                 if (_ptr_group_attrs) {
4750                         NDR_PULL_ALLOC(ndr, r->group_attrs);
4751                 } else {
4752                         r->group_attrs = NULL;
4753                 }
4754                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4755                 if (_ptr_sids) {
4756                         NDR_PULL_ALLOC(ndr, r->sids);
4757                 } else {
4758                         r->sids = NULL;
4759                 }
4760                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
4761         }
4762         if (ndr_flags & NDR_BUFFERS) {
4763                 if (r->info_array) {
4764                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
4765                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4766                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
4767                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
4768                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
4769                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
4770                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4771                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
4772                                 if (_ptr_info_array) {
4773                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
4774                                 } else {
4775                                         r->info_array[cntr_info_array_1] = NULL;
4776                                 }
4777                         }
4778                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->num_memberships; cntr_info_array_1++) {
4779                                 if (r->info_array[cntr_info_array_1]) {
4780                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
4781                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
4782                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
4783                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
4784                                 }
4785                         }
4786                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
4787                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
4788                 }
4789                 if (r->group_attrs) {
4790                         _mem_save_group_attrs_0 = NDR_PULL_GET_MEM_CTX(ndr);
4791                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4792                         NDR_CHECK(ndr_pull_array_size(ndr, &r->group_attrs));
4793                         NDR_PULL_ALLOC_N(ndr, r->group_attrs, ndr_get_array_size(ndr, &r->group_attrs));
4794                         _mem_save_group_attrs_1 = NDR_PULL_GET_MEM_CTX(ndr);
4795                         NDR_PULL_SET_MEM_CTX(ndr, r->group_attrs, 0);
4796                         for (cntr_group_attrs_1 = 0; cntr_group_attrs_1 < r->num_memberships; cntr_group_attrs_1++) {
4797                                 NDR_CHECK(ndr_pull_samr_GroupAttrs(ndr, NDR_SCALARS, &r->group_attrs[cntr_group_attrs_1]));
4798                         }
4799                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_1, 0);
4800                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_group_attrs_0, 0);
4801                 }
4802                 if (r->sids) {
4803                         _mem_save_sids_0 = NDR_PULL_GET_MEM_CTX(ndr);
4804                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4805                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sids));
4806                         NDR_PULL_ALLOC_N(ndr, r->sids, ndr_get_array_size(ndr, &r->sids));
4807                         _mem_save_sids_1 = NDR_PULL_GET_MEM_CTX(ndr);
4808                         NDR_PULL_SET_MEM_CTX(ndr, r->sids, 0);
4809                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4810                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sids));
4811                                 if (_ptr_sids) {
4812                                         NDR_PULL_ALLOC(ndr, r->sids[cntr_sids_1]);
4813                                 } else {
4814                                         r->sids[cntr_sids_1] = NULL;
4815                                 }
4816                         }
4817                         for (cntr_sids_1 = 0; cntr_sids_1 < r->num_sids; cntr_sids_1++) {
4818                                 if (r->sids[cntr_sids_1]) {
4819                                         _mem_save_sids_2 = NDR_PULL_GET_MEM_CTX(ndr);
4820                                         NDR_PULL_SET_MEM_CTX(ndr, r->sids[cntr_sids_1], 0);
4821                                         NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids[cntr_sids_1]));
4822                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_2, 0);
4823                                 }
4824                         }
4825                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_1, 0);
4826                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sids_0, 0);
4827                 }
4828                 if (r->info_array) {
4829                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->num_memberships));
4830                 }
4831                 if (r->group_attrs) {
4832                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->group_attrs, r->num_memberships));
4833                 }
4834                 if (r->sids) {
4835                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->sids, r->num_sids));
4836                 }
4837         }
4838         return NDR_ERR_SUCCESS;
4839 }
4840
4841 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsCtr1 *r)
4842 {
4843         uint32_t cntr_info_array_1;
4844         uint32_t cntr_group_attrs_1;
4845         uint32_t cntr_sids_1;
4846         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsCtr1");
4847         ndr->depth++;
4848         ndr_print_NTSTATUS(ndr, "status", r->status);
4849         ndr_print_uint32(ndr, "num_memberships", r->num_memberships);
4850         ndr_print_uint32(ndr, "num_sids", r->num_sids);
4851         ndr_print_ptr(ndr, "info_array", r->info_array);
4852         ndr->depth++;
4853         if (r->info_array) {
4854                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->num_memberships);
4855                 ndr->depth++;
4856                 for (cntr_info_array_1=0;cntr_info_array_1<r->num_memberships;cntr_info_array_1++) {
4857                         char *idx_1=NULL;
4858                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
4859                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
4860                                 ndr->depth++;
4861                                 if (r->info_array[cntr_info_array_1]) {
4862                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
4863                                 }
4864                                 ndr->depth--;
4865                                 free(idx_1);
4866                         }
4867                 }
4868                 ndr->depth--;
4869         }
4870         ndr->depth--;
4871         ndr_print_ptr(ndr, "group_attrs", r->group_attrs);
4872         ndr->depth++;
4873         if (r->group_attrs) {
4874                 ndr->print(ndr, "%s: ARRAY(%d)", "group_attrs", (int)r->num_memberships);
4875                 ndr->depth++;
4876                 for (cntr_group_attrs_1=0;cntr_group_attrs_1<r->num_memberships;cntr_group_attrs_1++) {
4877                         char *idx_1=NULL;
4878                         if (asprintf(&idx_1, "[%d]", cntr_group_attrs_1) != -1) {
4879                                 ndr_print_samr_GroupAttrs(ndr, "group_attrs", r->group_attrs[cntr_group_attrs_1]);
4880                                 free(idx_1);
4881                         }
4882                 }
4883                 ndr->depth--;
4884         }
4885         ndr->depth--;
4886         ndr_print_ptr(ndr, "sids", r->sids);
4887         ndr->depth++;
4888         if (r->sids) {
4889                 ndr->print(ndr, "%s: ARRAY(%d)", "sids", (int)r->num_sids);
4890                 ndr->depth++;
4891                 for (cntr_sids_1=0;cntr_sids_1<r->num_sids;cntr_sids_1++) {
4892                         char *idx_1=NULL;
4893                         if (asprintf(&idx_1, "[%d]", cntr_sids_1) != -1) {
4894                                 ndr_print_ptr(ndr, "sids", r->sids[cntr_sids_1]);
4895                                 ndr->depth++;
4896                                 if (r->sids[cntr_sids_1]) {
4897                                         ndr_print_dom_sid28(ndr, "sids", r->sids[cntr_sids_1]);
4898                                 }
4899                                 ndr->depth--;
4900                                 free(idx_1);
4901                         }
4902                 }
4903                 ndr->depth--;
4904         }
4905         ndr->depth--;
4906         ndr->depth--;
4907 }
4908
4909 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsCtr *r)
4910 {
4911         if (ndr_flags & NDR_SCALARS) {
4912                 int level = ndr_push_get_switch_value(ndr, r);
4913                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
4914                 NDR_CHECK(ndr_push_union_align(ndr, 5));
4915                 switch (level) {
4916                         case 1: {
4917                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4918                         break; }
4919
4920                         default:
4921                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4922                 }
4923         }
4924         if (ndr_flags & NDR_BUFFERS) {
4925                 int level = ndr_push_get_switch_value(ndr, r);
4926                 switch (level) {
4927                         case 1:
4928                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4929                         break;
4930
4931                         default:
4932                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4933                 }
4934         }
4935         return NDR_ERR_SUCCESS;
4936 }
4937
4938 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsCtr *r)
4939 {
4940         int level;
4941         int32_t _level;
4942         level = ndr_pull_get_switch_value(ndr, r);
4943         if (ndr_flags & NDR_SCALARS) {
4944                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
4945                 if (_level != level) {
4946                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
4947                 }
4948                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
4949                 switch (level) {
4950                         case 1: {
4951                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
4952                         break; }
4953
4954                         default:
4955                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4956                 }
4957         }
4958         if (ndr_flags & NDR_BUFFERS) {
4959                 switch (level) {
4960                         case 1:
4961                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
4962                         break;
4963
4964                         default:
4965                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
4966                 }
4967         }
4968         return NDR_ERR_SUCCESS;
4969 }
4970
4971 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsCtr *r)
4972 {
4973         int level;
4974         level = ndr_print_get_switch_value(ndr, r);
4975         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsCtr");
4976         switch (level) {
4977                 case 1:
4978                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
4979                 break;
4980
4981                 default:
4982                         ndr_print_bad_level(ndr, name, level);
4983         }
4984 }
4985
4986 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMembershipsRequest1 *r)
4987 {
4988         uint32_t cntr_info_array_1;
4989         if (ndr_flags & NDR_SCALARS) {
4990                 NDR_CHECK(ndr_push_align(ndr, 5));
4991                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
4992                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array));
4993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
4994                 NDR_CHECK(ndr_push_drsuapi_DsMembershipType(ndr, NDR_SCALARS, r->type));
4995                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain));
4996                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
4997         }
4998         if (ndr_flags & NDR_BUFFERS) {
4999                 if (r->info_array) {
5000                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5001                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5002                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info_array[cntr_info_array_1]));
5003                         }
5004                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5005                                 if (r->info_array[cntr_info_array_1]) {
5006                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5007                                 }
5008                         }
5009                 }
5010                 if (r->domain) {
5011                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5012                 }
5013         }
5014         return NDR_ERR_SUCCESS;
5015 }
5016
5017 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMembershipsRequest1 *r)
5018 {
5019         uint32_t _ptr_info_array;
5020         uint32_t cntr_info_array_1;
5021         TALLOC_CTX *_mem_save_info_array_0;
5022         TALLOC_CTX *_mem_save_info_array_1;
5023         TALLOC_CTX *_mem_save_info_array_2;
5024         uint32_t _ptr_domain;
5025         TALLOC_CTX *_mem_save_domain_0;
5026         if (ndr_flags & NDR_SCALARS) {
5027                 NDR_CHECK(ndr_pull_align(ndr, 5));
5028                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5029                 if (r->count < 1 || r->count > 10000) {
5030                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5031                 }
5032                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5033                 if (_ptr_info_array) {
5034                         NDR_PULL_ALLOC(ndr, r->info_array);
5035                 } else {
5036                         r->info_array = NULL;
5037                 }
5038                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
5039                 NDR_CHECK(ndr_pull_drsuapi_DsMembershipType(ndr, NDR_SCALARS, &r->type));
5040                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain));
5041                 if (_ptr_domain) {
5042                         NDR_PULL_ALLOC(ndr, r->domain);
5043                 } else {
5044                         r->domain = NULL;
5045                 }
5046                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5047         }
5048         if (ndr_flags & NDR_BUFFERS) {
5049                 if (r->info_array) {
5050                         _mem_save_info_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
5051                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5052                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info_array));
5053                         NDR_PULL_ALLOC_N(ndr, r->info_array, ndr_get_array_size(ndr, &r->info_array));
5054                         _mem_save_info_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
5055                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array, 0);
5056                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5057                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info_array));
5058                                 if (_ptr_info_array) {
5059                                         NDR_PULL_ALLOC(ndr, r->info_array[cntr_info_array_1]);
5060                                 } else {
5061                                         r->info_array[cntr_info_array_1] = NULL;
5062                                 }
5063                         }
5064                         for (cntr_info_array_1 = 0; cntr_info_array_1 < r->count; cntr_info_array_1++) {
5065                                 if (r->info_array[cntr_info_array_1]) {
5066                                         _mem_save_info_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
5067                                         NDR_PULL_SET_MEM_CTX(ndr, r->info_array[cntr_info_array_1], 0);
5068                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->info_array[cntr_info_array_1]));
5069                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_2, 0);
5070                                 }
5071                         }
5072                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_1, 0);
5073                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_array_0, 0);
5074                 }
5075                 if (r->domain) {
5076                         _mem_save_domain_0 = NDR_PULL_GET_MEM_CTX(ndr);
5077                         NDR_PULL_SET_MEM_CTX(ndr, r->domain, 0);
5078                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->domain));
5079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_0, 0);
5080                 }
5081                 if (r->info_array) {
5082                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info_array, r->count));
5083                 }
5084         }
5085         return NDR_ERR_SUCCESS;
5086 }
5087
5088 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsRequest1 *r)
5089 {
5090         uint32_t cntr_info_array_1;
5091         ndr_print_struct(ndr, name, "drsuapi_DsGetMembershipsRequest1");
5092         ndr->depth++;
5093         ndr_print_uint32(ndr, "count", r->count);
5094         ndr_print_ptr(ndr, "info_array", r->info_array);
5095         ndr->depth++;
5096         if (r->info_array) {
5097                 ndr->print(ndr, "%s: ARRAY(%d)", "info_array", (int)r->count);
5098                 ndr->depth++;
5099                 for (cntr_info_array_1=0;cntr_info_array_1<r->count;cntr_info_array_1++) {
5100                         char *idx_1=NULL;
5101                         if (asprintf(&idx_1, "[%d]", cntr_info_array_1) != -1) {
5102                                 ndr_print_ptr(ndr, "info_array", r->info_array[cntr_info_array_1]);
5103                                 ndr->depth++;
5104                                 if (r->info_array[cntr_info_array_1]) {
5105                                         ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "info_array", r->info_array[cntr_info_array_1]);
5106                                 }
5107                                 ndr->depth--;
5108                                 free(idx_1);
5109                         }
5110                 }
5111                 ndr->depth--;
5112         }
5113         ndr->depth--;
5114         ndr_print_uint32(ndr, "flags", r->flags);
5115         ndr_print_drsuapi_DsMembershipType(ndr, "type", r->type);
5116         ndr_print_ptr(ndr, "domain", r->domain);
5117         ndr->depth++;
5118         if (r->domain) {
5119                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "domain", r->domain);
5120         }
5121         ndr->depth--;
5122         ndr->depth--;
5123 }
5124
5125 static enum ndr_err_code ndr_push_drsuapi_DsGetMembershipsRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMembershipsRequest *r)
5126 {
5127         if (ndr_flags & NDR_SCALARS) {
5128                 int level = ndr_push_get_switch_value(ndr, r);
5129                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5130                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5131                 switch (level) {
5132                         case 1: {
5133                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5134                         break; }
5135
5136                         default:
5137                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5138                 }
5139         }
5140         if (ndr_flags & NDR_BUFFERS) {
5141                 int level = ndr_push_get_switch_value(ndr, r);
5142                 switch (level) {
5143                         case 1:
5144                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5145                         break;
5146
5147                         default:
5148                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5149                 }
5150         }
5151         return NDR_ERR_SUCCESS;
5152 }
5153
5154 static enum ndr_err_code ndr_pull_drsuapi_DsGetMembershipsRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMembershipsRequest *r)
5155 {
5156         int level;
5157         int32_t _level;
5158         level = ndr_pull_get_switch_value(ndr, r);
5159         if (ndr_flags & NDR_SCALARS) {
5160                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5161                 if (_level != level) {
5162                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5163                 }
5164                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5165                 switch (level) {
5166                         case 1: {
5167                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS, &r->req1));
5168                         break; }
5169
5170                         default:
5171                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5172                 }
5173         }
5174         if (ndr_flags & NDR_BUFFERS) {
5175                 switch (level) {
5176                         case 1:
5177                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_BUFFERS, &r->req1));
5178                         break;
5179
5180                         default:
5181                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5182                 }
5183         }
5184         return NDR_ERR_SUCCESS;
5185 }
5186
5187 _PUBLIC_ void ndr_print_drsuapi_DsGetMembershipsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsRequest *r)
5188 {
5189         int level;
5190         level = ndr_print_get_switch_value(ndr, r);
5191         ndr_print_union(ndr, name, level, "drsuapi_DsGetMembershipsRequest");
5192         switch (level) {
5193                 case 1:
5194                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req1", &r->req1);
5195                 break;
5196
5197                 default:
5198                         ndr_print_bad_level(ndr, name, level);
5199         }
5200 }
5201
5202 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5203 {
5204         if (ndr_flags & NDR_SCALARS) {
5205                 NDR_CHECK(ndr_push_align(ndr, 5));
5206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
5207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
5208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length));
5209                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
5210                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5211         }
5212         if (ndr_flags & NDR_BUFFERS) {
5213                 if (r->data) {
5214                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length));
5215                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->length));
5216                 }
5217         }
5218         return NDR_ERR_SUCCESS;
5219 }
5220
5221 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5222 {
5223         uint32_t _ptr_data;
5224         TALLOC_CTX *_mem_save_data_0;
5225         if (ndr_flags & NDR_SCALARS) {
5226                 NDR_CHECK(ndr_pull_align(ndr, 5));
5227                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
5228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
5229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length));
5230                 if (r->length > 0x00A00000) {
5231                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5232                 }
5233                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
5234                 if (_ptr_data) {
5235                         NDR_PULL_ALLOC(ndr, r->data);
5236                 } else {
5237                         r->data = NULL;
5238                 }
5239                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5240         }
5241         if (ndr_flags & NDR_BUFFERS) {
5242                 if (r->data) {
5243                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
5244                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
5245                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
5246                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
5247                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
5248                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
5249                 }
5250                 if (r->data) {
5251                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->length));
5252                 }
5253         }
5254         return NDR_ERR_SUCCESS;
5255 }
5256
5257 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogRequest1 *r)
5258 {
5259         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogRequest1");
5260         ndr->depth++;
5261         ndr_print_uint32(ndr, "unknown1", r->unknown1);
5262         ndr_print_uint32(ndr, "unknown2", r->unknown2);
5263         ndr_print_uint32(ndr, "length", r->length);
5264         ndr_print_ptr(ndr, "data", r->data);
5265         ndr->depth++;
5266         if (r->data) {
5267                 ndr_print_array_uint8(ndr, "data", r->data, r->length);
5268         }
5269         ndr->depth--;
5270         ndr->depth--;
5271 }
5272
5273 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5274 {
5275         if (ndr_flags & NDR_SCALARS) {
5276                 int level = ndr_push_get_switch_value(ndr, r);
5277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5278                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5279                 switch (level) {
5280                         case 1: {
5281                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5282                         break; }
5283
5284                         default:
5285                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5286                 }
5287         }
5288         if (ndr_flags & NDR_BUFFERS) {
5289                 int level = ndr_push_get_switch_value(ndr, r);
5290                 switch (level) {
5291                         case 1:
5292                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5293                         break;
5294
5295                         default:
5296                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5297                 }
5298         }
5299         return NDR_ERR_SUCCESS;
5300 }
5301
5302 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogRequest *r)
5303 {
5304         int level;
5305         uint32_t _level;
5306         level = ndr_pull_get_switch_value(ndr, r);
5307         if (ndr_flags & NDR_SCALARS) {
5308                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5309                 if (_level != level) {
5310                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5311                 }
5312                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5313                 switch (level) {
5314                         case 1: {
5315                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_SCALARS, &r->req1));
5316                         break; }
5317
5318                         default:
5319                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5320                 }
5321         }
5322         if (ndr_flags & NDR_BUFFERS) {
5323                 switch (level) {
5324                         case 1:
5325                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest1(ndr, NDR_BUFFERS, &r->req1));
5326                         break;
5327
5328                         default:
5329                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5330                 }
5331         }
5332         return NDR_ERR_SUCCESS;
5333 }
5334
5335 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogRequest *r)
5336 {
5337         int level;
5338         level = ndr_print_get_switch_value(ndr, r);
5339         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogRequest");
5340         switch (level) {
5341                 case 1:
5342                         ndr_print_drsuapi_DsGetNT4ChangeLogRequest1(ndr, "req1", &r->req1);
5343                 break;
5344
5345                 default:
5346                         ndr_print_bad_level(ndr, name, level);
5347         }
5348 }
5349
5350 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5351 {
5352         if (ndr_flags & NDR_SCALARS) {
5353                 NDR_CHECK(ndr_push_align(ndr, 8));
5354                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length1));
5355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->length2));
5356                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown1));
5357                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time2));
5358                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown3));
5359                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time4));
5360                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->unknown5));
5361                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time6));
5362                 NDR_CHECK(ndr_push_NTSTATUS(ndr, NDR_SCALARS, r->status));
5363                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data1));
5364                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data2));
5365                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
5366         }
5367         if (ndr_flags & NDR_BUFFERS) {
5368                 if (r->data1) {
5369                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length1));
5370                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data1, r->length1));
5371                 }
5372                 if (r->data2) {
5373                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->length2));
5374                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data2, r->length2));
5375                 }
5376         }
5377         return NDR_ERR_SUCCESS;
5378 }
5379
5380 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5381 {
5382         uint32_t _ptr_data1;
5383         TALLOC_CTX *_mem_save_data1_0;
5384         uint32_t _ptr_data2;
5385         TALLOC_CTX *_mem_save_data2_0;
5386         if (ndr_flags & NDR_SCALARS) {
5387                 NDR_CHECK(ndr_pull_align(ndr, 8));
5388                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length1));
5389                 if (r->length1 > 0x00A00000) {
5390                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5391                 }
5392                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->length2));
5393                 if (r->length2 > 0x00A00000) {
5394                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5395                 }
5396                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown1));
5397                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time2));
5398                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown3));
5399                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time4));
5400                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->unknown5));
5401                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time6));
5402                 NDR_CHECK(ndr_pull_NTSTATUS(ndr, NDR_SCALARS, &r->status));
5403                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data1));
5404                 if (_ptr_data1) {
5405                         NDR_PULL_ALLOC(ndr, r->data1);
5406                 } else {
5407                         r->data1 = NULL;
5408                 }
5409                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data2));
5410                 if (_ptr_data2) {
5411                         NDR_PULL_ALLOC(ndr, r->data2);
5412                 } else {
5413                         r->data2 = NULL;
5414                 }
5415                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
5416         }
5417         if (ndr_flags & NDR_BUFFERS) {
5418                 if (r->data1) {
5419                         _mem_save_data1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5420                         NDR_PULL_SET_MEM_CTX(ndr, r->data1, 0);
5421                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data1));
5422                         NDR_PULL_ALLOC_N(ndr, r->data1, ndr_get_array_size(ndr, &r->data1));
5423                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data1, ndr_get_array_size(ndr, &r->data1)));
5424                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data1_0, 0);
5425                 }
5426                 if (r->data2) {
5427                         _mem_save_data2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5428                         NDR_PULL_SET_MEM_CTX(ndr, r->data2, 0);
5429                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data2));
5430                         NDR_PULL_ALLOC_N(ndr, r->data2, ndr_get_array_size(ndr, &r->data2));
5431                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data2, ndr_get_array_size(ndr, &r->data2)));
5432                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data2_0, 0);
5433                 }
5434                 if (r->data1) {
5435                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data1, r->length1));
5436                 }
5437                 if (r->data2) {
5438                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data2, r->length2));
5439                 }
5440         }
5441         return NDR_ERR_SUCCESS;
5442 }
5443
5444 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetNT4ChangeLogInfo1 *r)
5445 {
5446         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLogInfo1");
5447         ndr->depth++;
5448         ndr_print_uint32(ndr, "length1", r->length1);
5449         ndr_print_uint32(ndr, "length2", r->length2);
5450         ndr_print_hyper(ndr, "unknown1", r->unknown1);
5451         ndr_print_NTTIME(ndr, "time2", r->time2);
5452         ndr_print_hyper(ndr, "unknown3", r->unknown3);
5453         ndr_print_NTTIME(ndr, "time4", r->time4);
5454         ndr_print_hyper(ndr, "unknown5", r->unknown5);
5455         ndr_print_NTTIME(ndr, "time6", r->time6);
5456         ndr_print_NTSTATUS(ndr, "status", r->status);
5457         ndr_print_ptr(ndr, "data1", r->data1);
5458         ndr->depth++;
5459         if (r->data1) {
5460                 ndr_print_array_uint8(ndr, "data1", r->data1, r->length1);
5461         }
5462         ndr->depth--;
5463         ndr_print_ptr(ndr, "data2", r->data2);
5464         ndr->depth++;
5465         if (r->data2) {
5466                 ndr_print_array_uint8(ndr, "data2", r->data2, r->length2);
5467         }
5468         ndr->depth--;
5469         ndr->depth--;
5470 }
5471
5472 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5473 {
5474         if (ndr_flags & NDR_SCALARS) {
5475                 int level = ndr_push_get_switch_value(ndr, r);
5476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5477                 NDR_CHECK(ndr_push_union_align(ndr, 8));
5478                 switch (level) {
5479                         case 1: {
5480                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5481                         break; }
5482
5483                         default:
5484                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5485                 }
5486         }
5487         if (ndr_flags & NDR_BUFFERS) {
5488                 int level = ndr_push_get_switch_value(ndr, r);
5489                 switch (level) {
5490                         case 1:
5491                                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5492                         break;
5493
5494                         default:
5495                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5496                 }
5497         }
5498         return NDR_ERR_SUCCESS;
5499 }
5500
5501 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetNT4ChangeLogInfo *r)
5502 {
5503         int level;
5504         uint32_t _level;
5505         level = ndr_pull_get_switch_value(ndr, r);
5506         if (ndr_flags & NDR_SCALARS) {
5507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5508                 if (_level != level) {
5509                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5510                 }
5511                 NDR_CHECK(ndr_pull_union_align(ndr, 8));
5512                 switch (level) {
5513                         case 1: {
5514                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_SCALARS, &r->info1));
5515                         break; }
5516
5517                         default:
5518                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5519                 }
5520         }
5521         if (ndr_flags & NDR_BUFFERS) {
5522                 switch (level) {
5523                         case 1:
5524                                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo1(ndr, NDR_BUFFERS, &r->info1));
5525                         break;
5526
5527                         default:
5528                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5529                 }
5530         }
5531         return NDR_ERR_SUCCESS;
5532 }
5533
5534 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLogInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetNT4ChangeLogInfo *r)
5535 {
5536         int level;
5537         level = ndr_print_get_switch_value(ndr, r);
5538         ndr_print_union(ndr, name, level, "drsuapi_DsGetNT4ChangeLogInfo");
5539         switch (level) {
5540                 case 1:
5541                         ndr_print_drsuapi_DsGetNT4ChangeLogInfo1(ndr, "info1", &r->info1);
5542                 break;
5543
5544                 default:
5545                         ndr_print_bad_level(ndr, name, level);
5546         }
5547 }
5548
5549 static enum ndr_err_code ndr_push_drsuapi_DsNameStatus(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameStatus r)
5550 {
5551         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5552         return NDR_ERR_SUCCESS;
5553 }
5554
5555 static enum ndr_err_code ndr_pull_drsuapi_DsNameStatus(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameStatus *r)
5556 {
5557         uint32_t v;
5558         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5559         *r = v;
5560         return NDR_ERR_SUCCESS;
5561 }
5562
5563 _PUBLIC_ void ndr_print_drsuapi_DsNameStatus(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameStatus r)
5564 {
5565         const char *val = NULL;
5566
5567         switch (r) {
5568                 case DRSUAPI_DS_NAME_STATUS_OK: val = "DRSUAPI_DS_NAME_STATUS_OK"; break;
5569                 case DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR: val = "DRSUAPI_DS_NAME_STATUS_RESOLVE_ERROR"; break;
5570                 case DRSUAPI_DS_NAME_STATUS_NOT_FOUND: val = "DRSUAPI_DS_NAME_STATUS_NOT_FOUND"; break;
5571                 case DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE: val = "DRSUAPI_DS_NAME_STATUS_NOT_UNIQUE"; break;
5572                 case DRSUAPI_DS_NAME_STATUS_NO_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_MAPPING"; break;
5573                 case DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY: val = "DRSUAPI_DS_NAME_STATUS_DOMAIN_ONLY"; break;
5574                 case DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING: val = "DRSUAPI_DS_NAME_STATUS_NO_SYNTACTICAL_MAPPING"; break;
5575                 case DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_STATUS_TRUST_REFERRAL"; break;
5576         }
5577         ndr_print_enum(ndr, name, "ENUM", val, r);
5578 }
5579
5580 static enum ndr_err_code ndr_push_drsuapi_DsNameFlags(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFlags r)
5581 {
5582         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5583         return NDR_ERR_SUCCESS;
5584 }
5585
5586 static enum ndr_err_code ndr_pull_drsuapi_DsNameFlags(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFlags *r)
5587 {
5588         uint32_t v;
5589         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5590         *r = v;
5591         return NDR_ERR_SUCCESS;
5592 }
5593
5594 _PUBLIC_ void ndr_print_drsuapi_DsNameFlags(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFlags r)
5595 {
5596         const char *val = NULL;
5597
5598         switch (r) {
5599                 case DRSUAPI_DS_NAME_FLAG_NO_FLAGS: val = "DRSUAPI_DS_NAME_FLAG_NO_FLAGS"; break;
5600                 case DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY: val = "DRSUAPI_DS_NAME_FLAG_SYNTACTICAL_ONLY"; break;
5601                 case DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC: val = "DRSUAPI_DS_NAME_FLAG_EVAL_AT_DC"; break;
5602                 case DRSUAPI_DS_NAME_FLAG_GCVERIFY: val = "DRSUAPI_DS_NAME_FLAG_GCVERIFY"; break;
5603                 case DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL: val = "DRSUAPI_DS_NAME_FLAG_TRUST_REFERRAL"; break;
5604         }
5605         ndr_print_enum(ndr, name, "ENUM", val, r);
5606 }
5607
5608 static enum ndr_err_code ndr_push_drsuapi_DsNameFormat(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsNameFormat r)
5609 {
5610         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
5611         return NDR_ERR_SUCCESS;
5612 }
5613
5614 static enum ndr_err_code ndr_pull_drsuapi_DsNameFormat(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsNameFormat *r)
5615 {
5616         uint32_t v;
5617         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
5618         *r = v;
5619         return NDR_ERR_SUCCESS;
5620 }
5621
5622 _PUBLIC_ void ndr_print_drsuapi_DsNameFormat(struct ndr_print *ndr, const char *name, enum drsuapi_DsNameFormat r)
5623 {
5624         const char *val = NULL;
5625
5626         switch (r) {
5627                 case DRSUAPI_DS_NAME_FORMAT_UNKNOWN: val = "DRSUAPI_DS_NAME_FORMAT_UNKNOWN"; break;
5628                 case DRSUAPI_DS_NAME_FORMAT_FQDN_1779: val = "DRSUAPI_DS_NAME_FORMAT_FQDN_1779"; break;
5629                 case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT: val = "DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT"; break;
5630                 case DRSUAPI_DS_NAME_FORMAT_DISPLAY: val = "DRSUAPI_DS_NAME_FORMAT_DISPLAY"; break;
5631                 case DRSUAPI_DS_NAME_FORMAT_GUID: val = "DRSUAPI_DS_NAME_FORMAT_GUID"; break;
5632                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL"; break;
5633                 case DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_USER_PRINCIPAL"; break;
5634                 case DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX: val = "DRSUAPI_DS_NAME_FORMAT_CANONICAL_EX"; break;
5635                 case DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL: val = "DRSUAPI_DS_NAME_FORMAT_SERVICE_PRINCIPAL"; break;
5636                 case DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY: val = "DRSUAPI_DS_NAME_FORMAT_SID_OR_SID_HISTORY"; break;
5637                 case DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN: val = "DRSUAPI_DS_NAME_FORMAT_DNS_DOMAIN"; break;
5638         }
5639         ndr_print_enum(ndr, name, "ENUM", val, r);
5640 }
5641
5642 static enum ndr_err_code ndr_push_drsuapi_DsNameString(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameString *r)
5643 {
5644         if (ndr_flags & NDR_SCALARS) {
5645                 NDR_CHECK(ndr_push_align(ndr, 5));
5646                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str));
5647                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5648         }
5649         if (ndr_flags & NDR_BUFFERS) {
5650                 if (r->str) {
5651                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5652                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5653                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str, CH_UTF16)));
5654                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str, ndr_charset_length(r->str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5655                 }
5656         }
5657         return NDR_ERR_SUCCESS;
5658 }
5659
5660 static enum ndr_err_code ndr_pull_drsuapi_DsNameString(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameString *r)
5661 {
5662         uint32_t _ptr_str;
5663         TALLOC_CTX *_mem_save_str_0;
5664         if (ndr_flags & NDR_SCALARS) {
5665                 NDR_CHECK(ndr_pull_align(ndr, 5));
5666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
5667                 if (_ptr_str) {
5668                         NDR_PULL_ALLOC(ndr, r->str);
5669                 } else {
5670                         r->str = NULL;
5671                 }
5672                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5673         }
5674         if (ndr_flags & NDR_BUFFERS) {
5675                 if (r->str) {
5676                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
5677                         NDR_PULL_SET_MEM_CTX(ndr, r->str, 0);
5678                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str));
5679                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str));
5680                         if (ndr_get_array_length(ndr, &r->str) > ndr_get_array_size(ndr, &r->str)) {
5681                                 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));
5682                         }
5683                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t)));
5684                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str, ndr_get_array_length(ndr, &r->str), sizeof(uint16_t), CH_UTF16));
5685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
5686                 }
5687         }
5688         return NDR_ERR_SUCCESS;
5689 }
5690
5691 _PUBLIC_ void ndr_print_drsuapi_DsNameString(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameString *r)
5692 {
5693         ndr_print_struct(ndr, name, "drsuapi_DsNameString");
5694         ndr->depth++;
5695         ndr_print_ptr(ndr, "str", r->str);
5696         ndr->depth++;
5697         if (r->str) {
5698                 ndr_print_string(ndr, "str", r->str);
5699         }
5700         ndr->depth--;
5701         ndr->depth--;
5702 }
5703
5704 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameRequest1 *r)
5705 {
5706         uint32_t cntr_names_1;
5707         if (ndr_flags & NDR_SCALARS) {
5708                 NDR_CHECK(ndr_push_align(ndr, 5));
5709                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->codepage));
5710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->language));
5711                 NDR_CHECK(ndr_push_drsuapi_DsNameFlags(ndr, NDR_SCALARS, r->format_flags));
5712                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_offered));
5713                 NDR_CHECK(ndr_push_drsuapi_DsNameFormat(ndr, NDR_SCALARS, r->format_desired));
5714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->names));
5716                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5717         }
5718         if (ndr_flags & NDR_BUFFERS) {
5719                 if (r->names) {
5720                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5721                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5722                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5723                         }
5724                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5725                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5726                         }
5727                 }
5728         }
5729         return NDR_ERR_SUCCESS;
5730 }
5731
5732 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameRequest1 *r)
5733 {
5734         uint32_t _ptr_names;
5735         uint32_t cntr_names_1;
5736         TALLOC_CTX *_mem_save_names_0;
5737         TALLOC_CTX *_mem_save_names_1;
5738         if (ndr_flags & NDR_SCALARS) {
5739                 NDR_CHECK(ndr_pull_align(ndr, 5));
5740                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->codepage));
5741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->language));
5742                 NDR_CHECK(ndr_pull_drsuapi_DsNameFlags(ndr, NDR_SCALARS, &r->format_flags));
5743                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_offered));
5744                 NDR_CHECK(ndr_pull_drsuapi_DsNameFormat(ndr, NDR_SCALARS, &r->format_desired));
5745                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
5746                 if (r->count < 1 || r->count > 10000) {
5747                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5748                 }
5749                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_names));
5750                 if (_ptr_names) {
5751                         NDR_PULL_ALLOC(ndr, r->names);
5752                 } else {
5753                         r->names = NULL;
5754                 }
5755                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5756         }
5757         if (ndr_flags & NDR_BUFFERS) {
5758                 if (r->names) {
5759                         _mem_save_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5760                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5761                         NDR_CHECK(ndr_pull_array_size(ndr, &r->names));
5762                         NDR_PULL_ALLOC_N(ndr, r->names, ndr_get_array_size(ndr, &r->names));
5763                         _mem_save_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
5764                         NDR_PULL_SET_MEM_CTX(ndr, r->names, 0);
5765                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5766                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->names[cntr_names_1]));
5767                         }
5768                         for (cntr_names_1 = 0; cntr_names_1 < r->count; cntr_names_1++) {
5769                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->names[cntr_names_1]));
5770                         }
5771                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_1, 0);
5772                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_names_0, 0);
5773                 }
5774                 if (r->names) {
5775                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->names, r->count));
5776                 }
5777         }
5778         return NDR_ERR_SUCCESS;
5779 }
5780
5781 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameRequest1 *r)
5782 {
5783         uint32_t cntr_names_1;
5784         ndr_print_struct(ndr, name, "drsuapi_DsNameRequest1");
5785         ndr->depth++;
5786         ndr_print_uint32(ndr, "codepage", r->codepage);
5787         ndr_print_uint32(ndr, "language", r->language);
5788         ndr_print_drsuapi_DsNameFlags(ndr, "format_flags", r->format_flags);
5789         ndr_print_drsuapi_DsNameFormat(ndr, "format_offered", r->format_offered);
5790         ndr_print_drsuapi_DsNameFormat(ndr, "format_desired", r->format_desired);
5791         ndr_print_uint32(ndr, "count", r->count);
5792         ndr_print_ptr(ndr, "names", r->names);
5793         ndr->depth++;
5794         if (r->names) {
5795                 ndr->print(ndr, "%s: ARRAY(%d)", "names", (int)r->count);
5796                 ndr->depth++;
5797                 for (cntr_names_1=0;cntr_names_1<r->count;cntr_names_1++) {
5798                         char *idx_1=NULL;
5799                         if (asprintf(&idx_1, "[%d]", cntr_names_1) != -1) {
5800                                 ndr_print_drsuapi_DsNameString(ndr, "names", &r->names[cntr_names_1]);
5801                                 free(idx_1);
5802                         }
5803                 }
5804                 ndr->depth--;
5805         }
5806         ndr->depth--;
5807         ndr->depth--;
5808 }
5809
5810 static enum ndr_err_code ndr_push_drsuapi_DsNameRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameRequest *r)
5811 {
5812         if (ndr_flags & NDR_SCALARS) {
5813                 int level = ndr_push_get_switch_value(ndr, r);
5814                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
5815                 NDR_CHECK(ndr_push_union_align(ndr, 5));
5816                 switch (level) {
5817                         case 1: {
5818                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5819                         break; }
5820
5821                         default:
5822                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5823                 }
5824         }
5825         if (ndr_flags & NDR_BUFFERS) {
5826                 int level = ndr_push_get_switch_value(ndr, r);
5827                 switch (level) {
5828                         case 1:
5829                                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5830                         break;
5831
5832                         default:
5833                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5834                 }
5835         }
5836         return NDR_ERR_SUCCESS;
5837 }
5838
5839 static enum ndr_err_code ndr_pull_drsuapi_DsNameRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameRequest *r)
5840 {
5841         int level;
5842         int32_t _level;
5843         level = ndr_pull_get_switch_value(ndr, r);
5844         if (ndr_flags & NDR_SCALARS) {
5845                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
5846                 if (_level != level) {
5847                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
5848                 }
5849                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
5850                 switch (level) {
5851                         case 1: {
5852                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_SCALARS, &r->req1));
5853                         break; }
5854
5855                         default:
5856                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5857                 }
5858         }
5859         if (ndr_flags & NDR_BUFFERS) {
5860                 switch (level) {
5861                         case 1:
5862                                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest1(ndr, NDR_BUFFERS, &r->req1));
5863                         break;
5864
5865                         default:
5866                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
5867                 }
5868         }
5869         return NDR_ERR_SUCCESS;
5870 }
5871
5872 _PUBLIC_ void ndr_print_drsuapi_DsNameRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameRequest *r)
5873 {
5874         int level;
5875         level = ndr_print_get_switch_value(ndr, r);
5876         ndr_print_union(ndr, name, level, "drsuapi_DsNameRequest");
5877         switch (level) {
5878                 case 1:
5879                         ndr_print_drsuapi_DsNameRequest1(ndr, "req1", &r->req1);
5880                 break;
5881
5882                 default:
5883                         ndr_print_bad_level(ndr, name, level);
5884         }
5885 }
5886
5887 static enum ndr_err_code ndr_push_drsuapi_DsNameInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameInfo1 *r)
5888 {
5889         if (ndr_flags & NDR_SCALARS) {
5890                 NDR_CHECK(ndr_push_align(ndr, 5));
5891                 NDR_CHECK(ndr_push_drsuapi_DsNameStatus(ndr, NDR_SCALARS, r->status));
5892                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_domain_name));
5893                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->result_name));
5894                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5895         }
5896         if (ndr_flags & NDR_BUFFERS) {
5897                 if (r->dns_domain_name) {
5898                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5899                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5900                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_domain_name, CH_UTF16)));
5901                         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));
5902                 }
5903                 if (r->result_name) {
5904                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5905                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
5906                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->result_name, CH_UTF16)));
5907                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->result_name, ndr_charset_length(r->result_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5908                 }
5909         }
5910         return NDR_ERR_SUCCESS;
5911 }
5912
5913 static enum ndr_err_code ndr_pull_drsuapi_DsNameInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameInfo1 *r)
5914 {
5915         uint32_t _ptr_dns_domain_name;
5916         TALLOC_CTX *_mem_save_dns_domain_name_0;
5917         uint32_t _ptr_result_name;
5918         TALLOC_CTX *_mem_save_result_name_0;
5919         if (ndr_flags & NDR_SCALARS) {
5920                 NDR_CHECK(ndr_pull_align(ndr, 5));
5921                 NDR_CHECK(ndr_pull_drsuapi_DsNameStatus(ndr, NDR_SCALARS, &r->status));
5922                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_domain_name));
5923                 if (_ptr_dns_domain_name) {
5924                         NDR_PULL_ALLOC(ndr, r->dns_domain_name);
5925                 } else {
5926                         r->dns_domain_name = NULL;
5927                 }
5928                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_result_name));
5929                 if (_ptr_result_name) {
5930                         NDR_PULL_ALLOC(ndr, r->result_name);
5931                 } else {
5932                         r->result_name = NULL;
5933                 }
5934                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
5935         }
5936         if (ndr_flags & NDR_BUFFERS) {
5937                 if (r->dns_domain_name) {
5938                         _mem_save_dns_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5939                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_domain_name, 0);
5940                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_domain_name));
5941                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_domain_name));
5942                         if (ndr_get_array_length(ndr, &r->dns_domain_name) > ndr_get_array_size(ndr, &r->dns_domain_name)) {
5943                                 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));
5944                         }
5945                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_domain_name), sizeof(uint16_t)));
5946                         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));
5947                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_domain_name_0, 0);
5948                 }
5949                 if (r->result_name) {
5950                         _mem_save_result_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5951                         NDR_PULL_SET_MEM_CTX(ndr, r->result_name, 0);
5952                         NDR_CHECK(ndr_pull_array_size(ndr, &r->result_name));
5953                         NDR_CHECK(ndr_pull_array_length(ndr, &r->result_name));
5954                         if (ndr_get_array_length(ndr, &r->result_name) > ndr_get_array_size(ndr, &r->result_name)) {
5955                                 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));
5956                         }
5957                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t)));
5958                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->result_name, ndr_get_array_length(ndr, &r->result_name), sizeof(uint16_t), CH_UTF16));
5959                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_result_name_0, 0);
5960                 }
5961         }
5962         return NDR_ERR_SUCCESS;
5963 }
5964
5965 _PUBLIC_ void ndr_print_drsuapi_DsNameInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameInfo1 *r)
5966 {
5967         ndr_print_struct(ndr, name, "drsuapi_DsNameInfo1");
5968         ndr->depth++;
5969         ndr_print_drsuapi_DsNameStatus(ndr, "status", r->status);
5970         ndr_print_ptr(ndr, "dns_domain_name", r->dns_domain_name);
5971         ndr->depth++;
5972         if (r->dns_domain_name) {
5973                 ndr_print_string(ndr, "dns_domain_name", r->dns_domain_name);
5974         }
5975         ndr->depth--;
5976         ndr_print_ptr(ndr, "result_name", r->result_name);
5977         ndr->depth++;
5978         if (r->result_name) {
5979                 ndr_print_string(ndr, "result_name", r->result_name);
5980         }
5981         ndr->depth--;
5982         ndr->depth--;
5983 }
5984
5985 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsNameCtr1 *r)
5986 {
5987         uint32_t cntr_array_1;
5988         if (ndr_flags & NDR_SCALARS) {
5989                 NDR_CHECK(ndr_push_align(ndr, 5));
5990                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
5991                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
5992                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
5993         }
5994         if (ndr_flags & NDR_BUFFERS) {
5995                 if (r->array) {
5996                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
5997                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
5998                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
5999                         }
6000                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6001                                 NDR_CHECK(ndr_push_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6002                         }
6003                 }
6004         }
6005         return NDR_ERR_SUCCESS;
6006 }
6007
6008 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsNameCtr1 *r)
6009 {
6010         uint32_t _ptr_array;
6011         uint32_t cntr_array_1;
6012         TALLOC_CTX *_mem_save_array_0;
6013         TALLOC_CTX *_mem_save_array_1;
6014         if (ndr_flags & NDR_SCALARS) {
6015                 NDR_CHECK(ndr_pull_align(ndr, 5));
6016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6017                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
6018                 if (_ptr_array) {
6019                         NDR_PULL_ALLOC(ndr, r->array);
6020                 } else {
6021                         r->array = NULL;
6022                 }
6023                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6024         }
6025         if (ndr_flags & NDR_BUFFERS) {
6026                 if (r->array) {
6027                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
6028                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6029                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
6030                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
6031                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
6032                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
6033                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6034                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
6035                         }
6036                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
6037                                 NDR_CHECK(ndr_pull_drsuapi_DsNameInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
6038                         }
6039                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
6040                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
6041                 }
6042                 if (r->array) {
6043                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
6044                 }
6045         }
6046         return NDR_ERR_SUCCESS;
6047 }
6048
6049 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsNameCtr1 *r)
6050 {
6051         uint32_t cntr_array_1;
6052         ndr_print_struct(ndr, name, "drsuapi_DsNameCtr1");
6053         ndr->depth++;
6054         ndr_print_uint32(ndr, "count", r->count);
6055         ndr_print_ptr(ndr, "array", r->array);
6056         ndr->depth++;
6057         if (r->array) {
6058                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
6059                 ndr->depth++;
6060                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
6061                         char *idx_1=NULL;
6062                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
6063                                 ndr_print_drsuapi_DsNameInfo1(ndr, "array", &r->array[cntr_array_1]);
6064                                 free(idx_1);
6065                         }
6066                 }
6067                 ndr->depth--;
6068         }
6069         ndr->depth--;
6070         ndr->depth--;
6071 }
6072
6073 static enum ndr_err_code ndr_push_drsuapi_DsNameCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsNameCtr *r)
6074 {
6075         if (ndr_flags & NDR_SCALARS) {
6076                 int level = ndr_push_get_switch_value(ndr, r);
6077                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6078                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6079                 switch (level) {
6080                         case 1: {
6081                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ctr1));
6082                         break; }
6083
6084                         default:
6085                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6086                 }
6087         }
6088         if (ndr_flags & NDR_BUFFERS) {
6089                 int level = ndr_push_get_switch_value(ndr, r);
6090                 switch (level) {
6091                         case 1:
6092                                 if (r->ctr1) {
6093                                         NDR_CHECK(ndr_push_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6094                                 }
6095                         break;
6096
6097                         default:
6098                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6099                 }
6100         }
6101         return NDR_ERR_SUCCESS;
6102 }
6103
6104 static enum ndr_err_code ndr_pull_drsuapi_DsNameCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsNameCtr *r)
6105 {
6106         int level;
6107         int32_t _level;
6108         TALLOC_CTX *_mem_save_ctr1_0;
6109         level = ndr_pull_get_switch_value(ndr, r);
6110         if (ndr_flags & NDR_SCALARS) {
6111                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6112                 if (_level != level) {
6113                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6114                 }
6115                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6116                 switch (level) {
6117                         case 1: {
6118                                 uint32_t _ptr_ctr1;
6119                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr1));
6120                                 if (_ptr_ctr1) {
6121                                         NDR_PULL_ALLOC(ndr, r->ctr1);
6122                                 } else {
6123                                         r->ctr1 = NULL;
6124                                 }
6125                         break; }
6126
6127                         default:
6128                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6129                 }
6130         }
6131         if (ndr_flags & NDR_BUFFERS) {
6132                 switch (level) {
6133                         case 1:
6134                                 if (r->ctr1) {
6135                                         _mem_save_ctr1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6136                                         NDR_PULL_SET_MEM_CTX(ndr, r->ctr1, 0);
6137                                         NDR_CHECK(ndr_pull_drsuapi_DsNameCtr1(ndr, NDR_SCALARS|NDR_BUFFERS, r->ctr1));
6138                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr1_0, 0);
6139                                 }
6140                         break;
6141
6142                         default:
6143                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6144                 }
6145         }
6146         return NDR_ERR_SUCCESS;
6147 }
6148
6149 _PUBLIC_ void ndr_print_drsuapi_DsNameCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsNameCtr *r)
6150 {
6151         int level;
6152         level = ndr_print_get_switch_value(ndr, r);
6153         ndr_print_union(ndr, name, level, "drsuapi_DsNameCtr");
6154         switch (level) {
6155                 case 1:
6156                         ndr_print_ptr(ndr, "ctr1", r->ctr1);
6157                         ndr->depth++;
6158                         if (r->ctr1) {
6159                                 ndr_print_drsuapi_DsNameCtr1(ndr, "ctr1", r->ctr1);
6160                         }
6161                         ndr->depth--;
6162                 break;
6163
6164                 default:
6165                         ndr_print_bad_level(ndr, name, level);
6166         }
6167 }
6168
6169 static enum ndr_err_code ndr_push_drsuapi_DsSpnOperation(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsSpnOperation r)
6170 {
6171         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
6172         return NDR_ERR_SUCCESS;
6173 }
6174
6175 static enum ndr_err_code ndr_pull_drsuapi_DsSpnOperation(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsSpnOperation *r)
6176 {
6177         uint32_t v;
6178         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
6179         *r = v;
6180         return NDR_ERR_SUCCESS;
6181 }
6182
6183 _PUBLIC_ void ndr_print_drsuapi_DsSpnOperation(struct ndr_print *ndr, const char *name, enum drsuapi_DsSpnOperation r)
6184 {
6185         const char *val = NULL;
6186
6187         switch (r) {
6188                 case DRSUAPI_DS_SPN_OPERATION_ADD: val = "DRSUAPI_DS_SPN_OPERATION_ADD"; break;
6189                 case DRSUAPI_DS_SPN_OPERATION_REPLACE: val = "DRSUAPI_DS_SPN_OPERATION_REPLACE"; break;
6190                 case DRSUAPI_DS_SPN_OPERATION_DELETE: val = "DRSUAPI_DS_SPN_OPERATION_DELETE"; break;
6191         }
6192         ndr_print_enum(ndr, name, "ENUM", val, r);
6193 }
6194
6195 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6196 {
6197         uint32_t cntr_spn_names_1;
6198         if (ndr_flags & NDR_SCALARS) {
6199                 NDR_CHECK(ndr_push_align(ndr, 5));
6200                 NDR_CHECK(ndr_push_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, r->operation));
6201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
6202                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
6203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
6204                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->spn_names));
6205                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6206         }
6207         if (ndr_flags & NDR_BUFFERS) {
6208                 if (r->object_dn) {
6209                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6210                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6211                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
6212                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6213                 }
6214                 if (r->spn_names) {
6215                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
6216                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6217                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6218                         }
6219                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6220                                 NDR_CHECK(ndr_push_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6221                         }
6222                 }
6223         }
6224         return NDR_ERR_SUCCESS;
6225 }
6226
6227 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnRequest1 *r)
6228 {
6229         uint32_t _ptr_object_dn;
6230         TALLOC_CTX *_mem_save_object_dn_0;
6231         uint32_t _ptr_spn_names;
6232         uint32_t cntr_spn_names_1;
6233         TALLOC_CTX *_mem_save_spn_names_0;
6234         TALLOC_CTX *_mem_save_spn_names_1;
6235         if (ndr_flags & NDR_SCALARS) {
6236                 NDR_CHECK(ndr_pull_align(ndr, 5));
6237                 NDR_CHECK(ndr_pull_drsuapi_DsSpnOperation(ndr, NDR_SCALARS, &r->operation));
6238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
6239                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
6240                 if (_ptr_object_dn) {
6241                         NDR_PULL_ALLOC(ndr, r->object_dn);
6242                 } else {
6243                         r->object_dn = NULL;
6244                 }
6245                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
6246                 if (r->count > 10000) {
6247                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6248                 }
6249                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_spn_names));
6250                 if (_ptr_spn_names) {
6251                         NDR_PULL_ALLOC(ndr, r->spn_names);
6252                 } else {
6253                         r->spn_names = NULL;
6254                 }
6255                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6256         }
6257         if (ndr_flags & NDR_BUFFERS) {
6258                 if (r->object_dn) {
6259                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6260                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
6261                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
6262                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
6263                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
6264                                 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));
6265                         }
6266                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
6267                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
6268                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
6269                 }
6270                 if (r->spn_names) {
6271                         _mem_save_spn_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6272                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6273                         NDR_CHECK(ndr_pull_array_size(ndr, &r->spn_names));
6274                         NDR_PULL_ALLOC_N(ndr, r->spn_names, ndr_get_array_size(ndr, &r->spn_names));
6275                         _mem_save_spn_names_1 = NDR_PULL_GET_MEM_CTX(ndr);
6276                         NDR_PULL_SET_MEM_CTX(ndr, r->spn_names, 0);
6277                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6278                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_SCALARS, &r->spn_names[cntr_spn_names_1]));
6279                         }
6280                         for (cntr_spn_names_1 = 0; cntr_spn_names_1 < r->count; cntr_spn_names_1++) {
6281                                 NDR_CHECK(ndr_pull_drsuapi_DsNameString(ndr, NDR_BUFFERS, &r->spn_names[cntr_spn_names_1]));
6282                         }
6283                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_1, 0);
6284                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_spn_names_0, 0);
6285                 }
6286                 if (r->spn_names) {
6287                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->spn_names, r->count));
6288                 }
6289         }
6290         return NDR_ERR_SUCCESS;
6291 }
6292
6293 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnRequest1 *r)
6294 {
6295         uint32_t cntr_spn_names_1;
6296         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnRequest1");
6297         ndr->depth++;
6298         ndr_print_drsuapi_DsSpnOperation(ndr, "operation", r->operation);
6299         ndr_print_uint32(ndr, "unknown1", r->unknown1);
6300         ndr_print_ptr(ndr, "object_dn", r->object_dn);
6301         ndr->depth++;
6302         if (r->object_dn) {
6303                 ndr_print_string(ndr, "object_dn", r->object_dn);
6304         }
6305         ndr->depth--;
6306         ndr_print_uint32(ndr, "count", r->count);
6307         ndr_print_ptr(ndr, "spn_names", r->spn_names);
6308         ndr->depth++;
6309         if (r->spn_names) {
6310                 ndr->print(ndr, "%s: ARRAY(%d)", "spn_names", (int)r->count);
6311                 ndr->depth++;
6312                 for (cntr_spn_names_1=0;cntr_spn_names_1<r->count;cntr_spn_names_1++) {
6313                         char *idx_1=NULL;
6314                         if (asprintf(&idx_1, "[%d]", cntr_spn_names_1) != -1) {
6315                                 ndr_print_drsuapi_DsNameString(ndr, "spn_names", &r->spn_names[cntr_spn_names_1]);
6316                                 free(idx_1);
6317                         }
6318                 }
6319                 ndr->depth--;
6320         }
6321         ndr->depth--;
6322         ndr->depth--;
6323 }
6324
6325 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnRequest *r)
6326 {
6327         if (ndr_flags & NDR_SCALARS) {
6328                 int level = ndr_push_get_switch_value(ndr, r);
6329                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6330                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6331                 switch (level) {
6332                         case 1: {
6333                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6334                         break; }
6335
6336                         default:
6337                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6338                 }
6339         }
6340         if (ndr_flags & NDR_BUFFERS) {
6341                 int level = ndr_push_get_switch_value(ndr, r);
6342                 switch (level) {
6343                         case 1:
6344                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6345                         break;
6346
6347                         default:
6348                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6349                 }
6350         }
6351         return NDR_ERR_SUCCESS;
6352 }
6353
6354 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnRequest *r)
6355 {
6356         int level;
6357         int32_t _level;
6358         level = ndr_pull_get_switch_value(ndr, r);
6359         if (ndr_flags & NDR_SCALARS) {
6360                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6361                 if (_level != level) {
6362                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6363                 }
6364                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6365                 switch (level) {
6366                         case 1: {
6367                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_SCALARS, &r->req1));
6368                         break; }
6369
6370                         default:
6371                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6372                 }
6373         }
6374         if (ndr_flags & NDR_BUFFERS) {
6375                 switch (level) {
6376                         case 1:
6377                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest1(ndr, NDR_BUFFERS, &r->req1));
6378                         break;
6379
6380                         default:
6381                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6382                 }
6383         }
6384         return NDR_ERR_SUCCESS;
6385 }
6386
6387 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnRequest *r)
6388 {
6389         int level;
6390         level = ndr_print_get_switch_value(ndr, r);
6391         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnRequest");
6392         switch (level) {
6393                 case 1:
6394                         ndr_print_drsuapi_DsWriteAccountSpnRequest1(ndr, "req1", &r->req1);
6395                 break;
6396
6397                 default:
6398                         ndr_print_bad_level(ndr, name, level);
6399         }
6400 }
6401
6402 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6403 {
6404         if (ndr_flags & NDR_SCALARS) {
6405                 NDR_CHECK(ndr_push_align(ndr, 4));
6406                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
6407                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6408         }
6409         if (ndr_flags & NDR_BUFFERS) {
6410         }
6411         return NDR_ERR_SUCCESS;
6412 }
6413
6414 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsWriteAccountSpnResult1 *r)
6415 {
6416         if (ndr_flags & NDR_SCALARS) {
6417                 NDR_CHECK(ndr_pull_align(ndr, 4));
6418                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
6419                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6420         }
6421         if (ndr_flags & NDR_BUFFERS) {
6422         }
6423         return NDR_ERR_SUCCESS;
6424 }
6425
6426 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsWriteAccountSpnResult1 *r)
6427 {
6428         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpnResult1");
6429         ndr->depth++;
6430         ndr_print_WERROR(ndr, "status", r->status);
6431         ndr->depth--;
6432 }
6433
6434 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpnResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsWriteAccountSpnResult *r)
6435 {
6436         if (ndr_flags & NDR_SCALARS) {
6437                 int level = ndr_push_get_switch_value(ndr, r);
6438                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6439                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6440                 switch (level) {
6441                         case 1: {
6442                                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6443                         break; }
6444
6445                         default:
6446                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6447                 }
6448         }
6449         if (ndr_flags & NDR_BUFFERS) {
6450                 int level = ndr_push_get_switch_value(ndr, r);
6451                 switch (level) {
6452                         case 1:
6453                         break;
6454
6455                         default:
6456                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6457                 }
6458         }
6459         return NDR_ERR_SUCCESS;
6460 }
6461
6462 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpnResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsWriteAccountSpnResult *r)
6463 {
6464         int level;
6465         int32_t _level;
6466         level = ndr_pull_get_switch_value(ndr, r);
6467         if (ndr_flags & NDR_SCALARS) {
6468                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6469                 if (_level != level) {
6470                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6471                 }
6472                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6473                 switch (level) {
6474                         case 1: {
6475                                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult1(ndr, NDR_SCALARS, &r->res1));
6476                         break; }
6477
6478                         default:
6479                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6480                 }
6481         }
6482         if (ndr_flags & NDR_BUFFERS) {
6483                 switch (level) {
6484                         case 1:
6485                         break;
6486
6487                         default:
6488                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6489                 }
6490         }
6491         return NDR_ERR_SUCCESS;
6492 }
6493
6494 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpnResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsWriteAccountSpnResult *r)
6495 {
6496         int level;
6497         level = ndr_print_get_switch_value(ndr, r);
6498         ndr_print_union(ndr, name, level, "drsuapi_DsWriteAccountSpnResult");
6499         switch (level) {
6500                 case 1:
6501                         ndr_print_drsuapi_DsWriteAccountSpnResult1(ndr, "res1", &r->res1);
6502                 break;
6503
6504                 default:
6505                         ndr_print_bad_level(ndr, name, level);
6506         }
6507 }
6508
6509 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6510 {
6511         if (ndr_flags & NDR_SCALARS) {
6512                 NDR_CHECK(ndr_push_align(ndr, 5));
6513                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6514                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_dn));
6515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->commit));
6516                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6517         }
6518         if (ndr_flags & NDR_BUFFERS) {
6519                 if (r->server_dn) {
6520                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6521                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6522                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6523                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6524                 }
6525                 if (r->domain_dn) {
6526                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6527                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6528                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_dn, CH_UTF16)));
6529                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_dn, ndr_charset_length(r->domain_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6530                 }
6531         }
6532         return NDR_ERR_SUCCESS;
6533 }
6534
6535 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerRequest1 *r)
6536 {
6537         uint32_t _ptr_server_dn;
6538         TALLOC_CTX *_mem_save_server_dn_0;
6539         uint32_t _ptr_domain_dn;
6540         TALLOC_CTX *_mem_save_domain_dn_0;
6541         if (ndr_flags & NDR_SCALARS) {
6542                 NDR_CHECK(ndr_pull_align(ndr, 5));
6543                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
6544                 if (_ptr_server_dn) {
6545                         NDR_PULL_ALLOC(ndr, r->server_dn);
6546                 } else {
6547                         r->server_dn = NULL;
6548                 }
6549                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_dn));
6550                 if (_ptr_domain_dn) {
6551                         NDR_PULL_ALLOC(ndr, r->domain_dn);
6552                 } else {
6553                         r->domain_dn = NULL;
6554                 }
6555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->commit));
6556                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6557         }
6558         if (ndr_flags & NDR_BUFFERS) {
6559                 if (r->server_dn) {
6560                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6561                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
6562                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
6563                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
6564                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
6565                                 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));
6566                         }
6567                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
6568                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
6569                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
6570                 }
6571                 if (r->domain_dn) {
6572                         _mem_save_domain_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
6573                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_dn, 0);
6574                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_dn));
6575                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_dn));
6576                         if (ndr_get_array_length(ndr, &r->domain_dn) > ndr_get_array_size(ndr, &r->domain_dn)) {
6577                                 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));
6578                         }
6579                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t)));
6580                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_dn, ndr_get_array_length(ndr, &r->domain_dn), sizeof(uint16_t), CH_UTF16));
6581                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_dn_0, 0);
6582                 }
6583         }
6584         return NDR_ERR_SUCCESS;
6585 }
6586
6587 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerRequest1 *r)
6588 {
6589         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerRequest1");
6590         ndr->depth++;
6591         ndr_print_ptr(ndr, "server_dn", r->server_dn);
6592         ndr->depth++;
6593         if (r->server_dn) {
6594                 ndr_print_string(ndr, "server_dn", r->server_dn);
6595         }
6596         ndr->depth--;
6597         ndr_print_ptr(ndr, "domain_dn", r->domain_dn);
6598         ndr->depth++;
6599         if (r->domain_dn) {
6600                 ndr_print_string(ndr, "domain_dn", r->domain_dn);
6601         }
6602         ndr->depth--;
6603         ndr_print_uint32(ndr, "commit", r->commit);
6604         ndr->depth--;
6605 }
6606
6607 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerRequest *r)
6608 {
6609         if (ndr_flags & NDR_SCALARS) {
6610                 int level = ndr_push_get_switch_value(ndr, r);
6611                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6612                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6613                 switch (level) {
6614                         case 1: {
6615                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6616                         break; }
6617
6618                         default:
6619                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6620                 }
6621         }
6622         if (ndr_flags & NDR_BUFFERS) {
6623                 int level = ndr_push_get_switch_value(ndr, r);
6624                 switch (level) {
6625                         case 1:
6626                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6627                         break;
6628
6629                         default:
6630                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6631                 }
6632         }
6633         return NDR_ERR_SUCCESS;
6634 }
6635
6636 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerRequest *r)
6637 {
6638         int level;
6639         int32_t _level;
6640         level = ndr_pull_get_switch_value(ndr, r);
6641         if (ndr_flags & NDR_SCALARS) {
6642                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6643                 if (_level != level) {
6644                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6645                 }
6646                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6647                 switch (level) {
6648                         case 1: {
6649                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_SCALARS, &r->req1));
6650                         break; }
6651
6652                         default:
6653                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6654                 }
6655         }
6656         if (ndr_flags & NDR_BUFFERS) {
6657                 switch (level) {
6658                         case 1:
6659                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest1(ndr, NDR_BUFFERS, &r->req1));
6660                         break;
6661
6662                         default:
6663                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6664                 }
6665         }
6666         return NDR_ERR_SUCCESS;
6667 }
6668
6669 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerRequest *r)
6670 {
6671         int level;
6672         level = ndr_print_get_switch_value(ndr, r);
6673         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerRequest");
6674         switch (level) {
6675                 case 1:
6676                         ndr_print_drsuapi_DsRemoveDSServerRequest1(ndr, "req1", &r->req1);
6677                 break;
6678
6679                 default:
6680                         ndr_print_bad_level(ndr, name, level);
6681         }
6682 }
6683
6684 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsRemoveDSServerResult1 *r)
6685 {
6686         if (ndr_flags & NDR_SCALARS) {
6687                 NDR_CHECK(ndr_push_align(ndr, 4));
6688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->last_dc_in_domain));
6689                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
6690         }
6691         if (ndr_flags & NDR_BUFFERS) {
6692         }
6693         return NDR_ERR_SUCCESS;
6694 }
6695
6696 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsRemoveDSServerResult1 *r)
6697 {
6698         if (ndr_flags & NDR_SCALARS) {
6699                 NDR_CHECK(ndr_pull_align(ndr, 4));
6700                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->last_dc_in_domain));
6701                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
6702         }
6703         if (ndr_flags & NDR_BUFFERS) {
6704         }
6705         return NDR_ERR_SUCCESS;
6706 }
6707
6708 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsRemoveDSServerResult1 *r)
6709 {
6710         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServerResult1");
6711         ndr->depth++;
6712         ndr_print_uint32(ndr, "last_dc_in_domain", r->last_dc_in_domain);
6713         ndr->depth--;
6714 }
6715
6716 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServerResult(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsRemoveDSServerResult *r)
6717 {
6718         if (ndr_flags & NDR_SCALARS) {
6719                 int level = ndr_push_get_switch_value(ndr, r);
6720                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6721                 NDR_CHECK(ndr_push_union_align(ndr, 4));
6722                 switch (level) {
6723                         case 1: {
6724                                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6725                         break; }
6726
6727                         default:
6728                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6729                 }
6730         }
6731         if (ndr_flags & NDR_BUFFERS) {
6732                 int level = ndr_push_get_switch_value(ndr, r);
6733                 switch (level) {
6734                         case 1:
6735                         break;
6736
6737                         default:
6738                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6739                 }
6740         }
6741         return NDR_ERR_SUCCESS;
6742 }
6743
6744 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServerResult(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsRemoveDSServerResult *r)
6745 {
6746         int level;
6747         int32_t _level;
6748         level = ndr_pull_get_switch_value(ndr, r);
6749         if (ndr_flags & NDR_SCALARS) {
6750                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6751                 if (_level != level) {
6752                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6753                 }
6754                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
6755                 switch (level) {
6756                         case 1: {
6757                                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult1(ndr, NDR_SCALARS, &r->res1));
6758                         break; }
6759
6760                         default:
6761                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6762                 }
6763         }
6764         if (ndr_flags & NDR_BUFFERS) {
6765                 switch (level) {
6766                         case 1:
6767                         break;
6768
6769                         default:
6770                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6771                 }
6772         }
6773         return NDR_ERR_SUCCESS;
6774 }
6775
6776 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServerResult(struct ndr_print *ndr, const char *name, const union drsuapi_DsRemoveDSServerResult *r)
6777 {
6778         int level;
6779         level = ndr_print_get_switch_value(ndr, r);
6780         ndr_print_union(ndr, name, level, "drsuapi_DsRemoveDSServerResult");
6781         switch (level) {
6782                 case 1:
6783                         ndr_print_drsuapi_DsRemoveDSServerResult1(ndr, "res1", &r->res1);
6784                 break;
6785
6786                 default:
6787                         ndr_print_bad_level(ndr, name, level);
6788         }
6789 }
6790
6791 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoRequest1 *r)
6792 {
6793         if (ndr_flags & NDR_SCALARS) {
6794                 NDR_CHECK(ndr_push_align(ndr, 5));
6795                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->domain_name));
6796                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->level));
6797                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6798         }
6799         if (ndr_flags & NDR_BUFFERS) {
6800                 if (r->domain_name) {
6801                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6803                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->domain_name, CH_UTF16)));
6804                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->domain_name, ndr_charset_length(r->domain_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6805                 }
6806         }
6807         return NDR_ERR_SUCCESS;
6808 }
6809
6810 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoRequest1 *r)
6811 {
6812         uint32_t _ptr_domain_name;
6813         TALLOC_CTX *_mem_save_domain_name_0;
6814         if (ndr_flags & NDR_SCALARS) {
6815                 NDR_CHECK(ndr_pull_align(ndr, 5));
6816                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_domain_name));
6817                 if (_ptr_domain_name) {
6818                         NDR_PULL_ALLOC(ndr, r->domain_name);
6819                 } else {
6820                         r->domain_name = NULL;
6821                 }
6822                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->level));
6823                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
6824         }
6825         if (ndr_flags & NDR_BUFFERS) {
6826                 if (r->domain_name) {
6827                         _mem_save_domain_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6828                         NDR_PULL_SET_MEM_CTX(ndr, r->domain_name, 0);
6829                         NDR_CHECK(ndr_pull_array_size(ndr, &r->domain_name));
6830                         NDR_CHECK(ndr_pull_array_length(ndr, &r->domain_name));
6831                         if (ndr_get_array_length(ndr, &r->domain_name) > ndr_get_array_size(ndr, &r->domain_name)) {
6832                                 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));
6833                         }
6834                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t)));
6835                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->domain_name, ndr_get_array_length(ndr, &r->domain_name), sizeof(uint16_t), CH_UTF16));
6836                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_domain_name_0, 0);
6837                 }
6838         }
6839         return NDR_ERR_SUCCESS;
6840 }
6841
6842 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoRequest1 *r)
6843 {
6844         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoRequest1");
6845         ndr->depth++;
6846         ndr_print_ptr(ndr, "domain_name", r->domain_name);
6847         ndr->depth++;
6848         if (r->domain_name) {
6849                 ndr_print_string(ndr, "domain_name", r->domain_name);
6850         }
6851         ndr->depth--;
6852         ndr_print_int32(ndr, "level", r->level);
6853         ndr->depth--;
6854 }
6855
6856 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoRequest *r)
6857 {
6858         if (ndr_flags & NDR_SCALARS) {
6859                 int level = ndr_push_get_switch_value(ndr, r);
6860                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
6861                 NDR_CHECK(ndr_push_union_align(ndr, 5));
6862                 switch (level) {
6863                         case 1: {
6864                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6865                         break; }
6866
6867                         default:
6868                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6869                 }
6870         }
6871         if (ndr_flags & NDR_BUFFERS) {
6872                 int level = ndr_push_get_switch_value(ndr, r);
6873                 switch (level) {
6874                         case 1:
6875                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6876                         break;
6877
6878                         default:
6879                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6880                 }
6881         }
6882         return NDR_ERR_SUCCESS;
6883 }
6884
6885 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoRequest *r)
6886 {
6887         int level;
6888         int32_t _level;
6889         level = ndr_pull_get_switch_value(ndr, r);
6890         if (ndr_flags & NDR_SCALARS) {
6891                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
6892                 if (_level != level) {
6893                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
6894                 }
6895                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
6896                 switch (level) {
6897                         case 1: {
6898                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_SCALARS, &r->req1));
6899                         break; }
6900
6901                         default:
6902                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6903                 }
6904         }
6905         if (ndr_flags & NDR_BUFFERS) {
6906                 switch (level) {
6907                         case 1:
6908                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
6909                         break;
6910
6911                         default:
6912                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
6913                 }
6914         }
6915         return NDR_ERR_SUCCESS;
6916 }
6917
6918 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoRequest *r)
6919 {
6920         int level;
6921         level = ndr_print_get_switch_value(ndr, r);
6922         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoRequest");
6923         switch (level) {
6924                 case 1:
6925                         ndr_print_drsuapi_DsGetDCInfoRequest1(ndr, "req1", &r->req1);
6926                 break;
6927
6928                 default:
6929                         ndr_print_bad_level(ndr, name, level);
6930         }
6931 }
6932
6933 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo1 *r)
6934 {
6935         if (ndr_flags & NDR_SCALARS) {
6936                 NDR_CHECK(ndr_push_align(ndr, 5));
6937                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
6938                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
6939                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
6940                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
6941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
6942                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
6943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
6944                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
6945         }
6946         if (ndr_flags & NDR_BUFFERS) {
6947                 if (r->netbios_name) {
6948                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6949                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6950                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
6951                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6952                 }
6953                 if (r->dns_name) {
6954                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6955                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6956                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
6957                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6958                 }
6959                 if (r->site_name) {
6960                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6961                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6962                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
6963                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6964                 }
6965                 if (r->computer_dn) {
6966                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6967                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6968                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
6969                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6970                 }
6971                 if (r->server_dn) {
6972                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6973                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
6974                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
6975                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6976                 }
6977         }
6978         return NDR_ERR_SUCCESS;
6979 }
6980
6981 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo1 *r)
6982 {
6983         uint32_t _ptr_netbios_name;
6984         TALLOC_CTX *_mem_save_netbios_name_0;
6985         uint32_t _ptr_dns_name;
6986         TALLOC_CTX *_mem_save_dns_name_0;
6987         uint32_t _ptr_site_name;
6988         TALLOC_CTX *_mem_save_site_name_0;
6989         uint32_t _ptr_computer_dn;
6990         TALLOC_CTX *_mem_save_computer_dn_0;
6991         uint32_t _ptr_server_dn;
6992         TALLOC_CTX *_mem_save_server_dn_0;
6993         if (ndr_flags & NDR_SCALARS) {
6994                 NDR_CHECK(ndr_pull_align(ndr, 5));
6995                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
6996                 if (_ptr_netbios_name) {
6997                         NDR_PULL_ALLOC(ndr, r->netbios_name);
6998                 } else {
6999                         r->netbios_name = NULL;
7000                 }
7001                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7002                 if (_ptr_dns_name) {
7003                         NDR_PULL_ALLOC(ndr, r->dns_name);
7004                 } else {
7005                         r->dns_name = NULL;
7006                 }
7007                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7008                 if (_ptr_site_name) {
7009                         NDR_PULL_ALLOC(ndr, r->site_name);
7010                 } else {
7011                         r->site_name = NULL;
7012                 }
7013                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7014                 if (_ptr_computer_dn) {
7015                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7016                 } else {
7017                         r->computer_dn = NULL;
7018                 }
7019                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7020                 if (_ptr_server_dn) {
7021                         NDR_PULL_ALLOC(ndr, r->server_dn);
7022                 } else {
7023                         r->server_dn = NULL;
7024                 }
7025                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7027                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7028         }
7029         if (ndr_flags & NDR_BUFFERS) {
7030                 if (r->netbios_name) {
7031                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7032                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7033                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7034                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7035                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7036                                 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));
7037                         }
7038                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7039                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7040                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7041                 }
7042                 if (r->dns_name) {
7043                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7044                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7045                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7046                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7047                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7048                                 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));
7049                         }
7050                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7051                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7052                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7053                 }
7054                 if (r->site_name) {
7055                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7056                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7057                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7058                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7059                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7060                                 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));
7061                         }
7062                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7063                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7064                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7065                 }
7066                 if (r->computer_dn) {
7067                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7068                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7069                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7070                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7071                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7072                                 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));
7073                         }
7074                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7075                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7076                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7077                 }
7078                 if (r->server_dn) {
7079                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7080                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7081                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7082                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7083                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7084                                 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));
7085                         }
7086                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7087                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7088                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7089                 }
7090         }
7091         return NDR_ERR_SUCCESS;
7092 }
7093
7094 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo1 *r)
7095 {
7096         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo1");
7097         ndr->depth++;
7098         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7099         ndr->depth++;
7100         if (r->netbios_name) {
7101                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7102         }
7103         ndr->depth--;
7104         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7105         ndr->depth++;
7106         if (r->dns_name) {
7107                 ndr_print_string(ndr, "dns_name", r->dns_name);
7108         }
7109         ndr->depth--;
7110         ndr_print_ptr(ndr, "site_name", r->site_name);
7111         ndr->depth++;
7112         if (r->site_name) {
7113                 ndr_print_string(ndr, "site_name", r->site_name);
7114         }
7115         ndr->depth--;
7116         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7117         ndr->depth++;
7118         if (r->computer_dn) {
7119                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7120         }
7121         ndr->depth--;
7122         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7123         ndr->depth++;
7124         if (r->server_dn) {
7125                 ndr_print_string(ndr, "server_dn", r->server_dn);
7126         }
7127         ndr->depth--;
7128         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7129         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7130         ndr->depth--;
7131 }
7132
7133 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr1 *r)
7134 {
7135         uint32_t cntr_array_1;
7136         if (ndr_flags & NDR_SCALARS) {
7137                 NDR_CHECK(ndr_push_align(ndr, 5));
7138                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7139                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7140                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7141         }
7142         if (ndr_flags & NDR_BUFFERS) {
7143                 if (r->array) {
7144                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7145                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7146                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7147                         }
7148                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7149                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7150                         }
7151                 }
7152         }
7153         return NDR_ERR_SUCCESS;
7154 }
7155
7156 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr1 *r)
7157 {
7158         uint32_t _ptr_array;
7159         uint32_t cntr_array_1;
7160         TALLOC_CTX *_mem_save_array_0;
7161         TALLOC_CTX *_mem_save_array_1;
7162         if (ndr_flags & NDR_SCALARS) {
7163                 NDR_CHECK(ndr_pull_align(ndr, 5));
7164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7165                 if (r->count > 10000) {
7166                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7167                 }
7168                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7169                 if (_ptr_array) {
7170                         NDR_PULL_ALLOC(ndr, r->array);
7171                 } else {
7172                         r->array = NULL;
7173                 }
7174                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7175         }
7176         if (ndr_flags & NDR_BUFFERS) {
7177                 if (r->array) {
7178                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7179                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7180                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7181                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7182                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7183                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7184                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7185                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7186                         }
7187                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7188                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo1(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7189                         }
7190                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7192                 }
7193                 if (r->array) {
7194                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7195                 }
7196         }
7197         return NDR_ERR_SUCCESS;
7198 }
7199
7200 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr1 *r)
7201 {
7202         uint32_t cntr_array_1;
7203         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr1");
7204         ndr->depth++;
7205         ndr_print_uint32(ndr, "count", r->count);
7206         ndr_print_ptr(ndr, "array", r->array);
7207         ndr->depth++;
7208         if (r->array) {
7209                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7210                 ndr->depth++;
7211                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7212                         char *idx_1=NULL;
7213                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7214                                 ndr_print_drsuapi_DsGetDCInfo1(ndr, "array", &r->array[cntr_array_1]);
7215                                 free(idx_1);
7216                         }
7217                 }
7218                 ndr->depth--;
7219         }
7220         ndr->depth--;
7221         ndr->depth--;
7222 }
7223
7224 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo2 *r)
7225 {
7226         if (ndr_flags & NDR_SCALARS) {
7227                 NDR_CHECK(ndr_push_align(ndr, 5));
7228                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7229                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7230                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7231                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7232                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7233                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7234                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7235                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7236                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7238                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7239                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7240                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7241                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7242                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7243         }
7244         if (ndr_flags & NDR_BUFFERS) {
7245                 if (r->netbios_name) {
7246                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7247                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7248                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7249                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7250                 }
7251                 if (r->dns_name) {
7252                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7253                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7254                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7255                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7256                 }
7257                 if (r->site_name) {
7258                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7259                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7260                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7261                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7262                 }
7263                 if (r->site_dn) {
7264                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7265                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7266                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7267                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7268                 }
7269                 if (r->computer_dn) {
7270                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7271                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7272                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7273                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7274                 }
7275                 if (r->server_dn) {
7276                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7277                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7278                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7279                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7280                 }
7281                 if (r->ntds_dn) {
7282                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7283                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7284                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7285                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7286                 }
7287         }
7288         return NDR_ERR_SUCCESS;
7289 }
7290
7291 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo2 *r)
7292 {
7293         uint32_t _ptr_netbios_name;
7294         TALLOC_CTX *_mem_save_netbios_name_0;
7295         uint32_t _ptr_dns_name;
7296         TALLOC_CTX *_mem_save_dns_name_0;
7297         uint32_t _ptr_site_name;
7298         TALLOC_CTX *_mem_save_site_name_0;
7299         uint32_t _ptr_site_dn;
7300         TALLOC_CTX *_mem_save_site_dn_0;
7301         uint32_t _ptr_computer_dn;
7302         TALLOC_CTX *_mem_save_computer_dn_0;
7303         uint32_t _ptr_server_dn;
7304         TALLOC_CTX *_mem_save_server_dn_0;
7305         uint32_t _ptr_ntds_dn;
7306         TALLOC_CTX *_mem_save_ntds_dn_0;
7307         if (ndr_flags & NDR_SCALARS) {
7308                 NDR_CHECK(ndr_pull_align(ndr, 5));
7309                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7310                 if (_ptr_netbios_name) {
7311                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7312                 } else {
7313                         r->netbios_name = NULL;
7314                 }
7315                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7316                 if (_ptr_dns_name) {
7317                         NDR_PULL_ALLOC(ndr, r->dns_name);
7318                 } else {
7319                         r->dns_name = NULL;
7320                 }
7321                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7322                 if (_ptr_site_name) {
7323                         NDR_PULL_ALLOC(ndr, r->site_name);
7324                 } else {
7325                         r->site_name = NULL;
7326                 }
7327                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7328                 if (_ptr_site_dn) {
7329                         NDR_PULL_ALLOC(ndr, r->site_dn);
7330                 } else {
7331                         r->site_dn = NULL;
7332                 }
7333                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7334                 if (_ptr_computer_dn) {
7335                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7336                 } else {
7337                         r->computer_dn = NULL;
7338                 }
7339                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7340                 if (_ptr_server_dn) {
7341                         NDR_PULL_ALLOC(ndr, r->server_dn);
7342                 } else {
7343                         r->server_dn = NULL;
7344                 }
7345                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7346                 if (_ptr_ntds_dn) {
7347                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7348                 } else {
7349                         r->ntds_dn = NULL;
7350                 }
7351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7354                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7355                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7356                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7357                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7358                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7359         }
7360         if (ndr_flags & NDR_BUFFERS) {
7361                 if (r->netbios_name) {
7362                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7363                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7364                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7365                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7366                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7367                                 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));
7368                         }
7369                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7370                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7371                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7372                 }
7373                 if (r->dns_name) {
7374                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7375                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7376                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7377                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7378                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7379                                 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));
7380                         }
7381                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7382                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7383                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7384                 }
7385                 if (r->site_name) {
7386                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7387                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7388                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7389                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7390                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7391                                 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));
7392                         }
7393                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7394                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7395                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7396                 }
7397                 if (r->site_dn) {
7398                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7399                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7400                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7401                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7402                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7403                                 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));
7404                         }
7405                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7406                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7407                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7408                 }
7409                 if (r->computer_dn) {
7410                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7411                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7412                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7413                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7414                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7415                                 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));
7416                         }
7417                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7418                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7419                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7420                 }
7421                 if (r->server_dn) {
7422                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7423                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7424                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7425                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7426                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7427                                 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));
7428                         }
7429                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7430                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7431                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7432                 }
7433                 if (r->ntds_dn) {
7434                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7435                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7436                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7437                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7438                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7439                                 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));
7440                         }
7441                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7442                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7443                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7444                 }
7445         }
7446         return NDR_ERR_SUCCESS;
7447 }
7448
7449 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo2 *r)
7450 {
7451         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo2");
7452         ndr->depth++;
7453         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7454         ndr->depth++;
7455         if (r->netbios_name) {
7456                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7457         }
7458         ndr->depth--;
7459         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7460         ndr->depth++;
7461         if (r->dns_name) {
7462                 ndr_print_string(ndr, "dns_name", r->dns_name);
7463         }
7464         ndr->depth--;
7465         ndr_print_ptr(ndr, "site_name", r->site_name);
7466         ndr->depth++;
7467         if (r->site_name) {
7468                 ndr_print_string(ndr, "site_name", r->site_name);
7469         }
7470         ndr->depth--;
7471         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7472         ndr->depth++;
7473         if (r->site_dn) {
7474                 ndr_print_string(ndr, "site_dn", r->site_dn);
7475         }
7476         ndr->depth--;
7477         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7478         ndr->depth++;
7479         if (r->computer_dn) {
7480                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7481         }
7482         ndr->depth--;
7483         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7484         ndr->depth++;
7485         if (r->server_dn) {
7486                 ndr_print_string(ndr, "server_dn", r->server_dn);
7487         }
7488         ndr->depth--;
7489         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7490         ndr->depth++;
7491         if (r->ntds_dn) {
7492                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7493         }
7494         ndr->depth--;
7495         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7496         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7497         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7498         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7499         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7500         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7501         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7502         ndr->depth--;
7503 }
7504
7505 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr2 *r)
7506 {
7507         uint32_t cntr_array_1;
7508         if (ndr_flags & NDR_SCALARS) {
7509                 NDR_CHECK(ndr_push_align(ndr, 5));
7510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7511                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7512                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7513         }
7514         if (ndr_flags & NDR_BUFFERS) {
7515                 if (r->array) {
7516                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7517                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7518                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7519                         }
7520                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7521                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7522                         }
7523                 }
7524         }
7525         return NDR_ERR_SUCCESS;
7526 }
7527
7528 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr2 *r)
7529 {
7530         uint32_t _ptr_array;
7531         uint32_t cntr_array_1;
7532         TALLOC_CTX *_mem_save_array_0;
7533         TALLOC_CTX *_mem_save_array_1;
7534         if (ndr_flags & NDR_SCALARS) {
7535                 NDR_CHECK(ndr_pull_align(ndr, 5));
7536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7537                 if (r->count > 10000) {
7538                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7539                 }
7540                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7541                 if (_ptr_array) {
7542                         NDR_PULL_ALLOC(ndr, r->array);
7543                 } else {
7544                         r->array = NULL;
7545                 }
7546                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7547         }
7548         if (ndr_flags & NDR_BUFFERS) {
7549                 if (r->array) {
7550                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7551                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7552                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7553                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7554                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7555                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7556                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7557                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7558                         }
7559                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7560                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo2(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7561                         }
7562                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7563                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7564                 }
7565                 if (r->array) {
7566                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7567                 }
7568         }
7569         return NDR_ERR_SUCCESS;
7570 }
7571
7572 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr2 *r)
7573 {
7574         uint32_t cntr_array_1;
7575         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr2");
7576         ndr->depth++;
7577         ndr_print_uint32(ndr, "count", r->count);
7578         ndr_print_ptr(ndr, "array", r->array);
7579         ndr->depth++;
7580         if (r->array) {
7581                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7582                 ndr->depth++;
7583                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7584                         char *idx_1=NULL;
7585                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7586                                 ndr_print_drsuapi_DsGetDCInfo2(ndr, "array", &r->array[cntr_array_1]);
7587                                 free(idx_1);
7588                         }
7589                 }
7590                 ndr->depth--;
7591         }
7592         ndr->depth--;
7593         ndr->depth--;
7594 }
7595
7596 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfo3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfo3 *r)
7597 {
7598         if (ndr_flags & NDR_SCALARS) {
7599                 NDR_CHECK(ndr_push_align(ndr, 5));
7600                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->netbios_name));
7601                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dns_name));
7602                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_name));
7603                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_dn));
7604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->computer_dn));
7605                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_dn));
7606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->ntds_dn));
7607                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_pdc));
7608                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_enabled));
7609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_gc));
7610                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->is_rodc));
7611                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->site_guid));
7612                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7613                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->server_guid));
7614                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7615                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7616         }
7617         if (ndr_flags & NDR_BUFFERS) {
7618                 if (r->netbios_name) {
7619                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7620                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7621                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->netbios_name, CH_UTF16)));
7622                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->netbios_name, ndr_charset_length(r->netbios_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7623                 }
7624                 if (r->dns_name) {
7625                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7626                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7627                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dns_name, CH_UTF16)));
7628                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->dns_name, ndr_charset_length(r->dns_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7629                 }
7630                 if (r->site_name) {
7631                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7632                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7633                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_name, CH_UTF16)));
7634                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_name, ndr_charset_length(r->site_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7635                 }
7636                 if (r->site_dn) {
7637                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7638                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7639                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_dn, CH_UTF16)));
7640                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_dn, ndr_charset_length(r->site_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7641                 }
7642                 if (r->computer_dn) {
7643                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7644                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7645                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->computer_dn, CH_UTF16)));
7646                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->computer_dn, ndr_charset_length(r->computer_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7647                 }
7648                 if (r->server_dn) {
7649                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7650                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7651                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->server_dn, CH_UTF16)));
7652                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_dn, ndr_charset_length(r->server_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7653                 }
7654                 if (r->ntds_dn) {
7655                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7656                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7657                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->ntds_dn, CH_UTF16)));
7658                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ntds_dn, ndr_charset_length(r->ntds_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7659                 }
7660         }
7661         return NDR_ERR_SUCCESS;
7662 }
7663
7664 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfo3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfo3 *r)
7665 {
7666         uint32_t _ptr_netbios_name;
7667         TALLOC_CTX *_mem_save_netbios_name_0;
7668         uint32_t _ptr_dns_name;
7669         TALLOC_CTX *_mem_save_dns_name_0;
7670         uint32_t _ptr_site_name;
7671         TALLOC_CTX *_mem_save_site_name_0;
7672         uint32_t _ptr_site_dn;
7673         TALLOC_CTX *_mem_save_site_dn_0;
7674         uint32_t _ptr_computer_dn;
7675         TALLOC_CTX *_mem_save_computer_dn_0;
7676         uint32_t _ptr_server_dn;
7677         TALLOC_CTX *_mem_save_server_dn_0;
7678         uint32_t _ptr_ntds_dn;
7679         TALLOC_CTX *_mem_save_ntds_dn_0;
7680         if (ndr_flags & NDR_SCALARS) {
7681                 NDR_CHECK(ndr_pull_align(ndr, 5));
7682                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_netbios_name));
7683                 if (_ptr_netbios_name) {
7684                         NDR_PULL_ALLOC(ndr, r->netbios_name);
7685                 } else {
7686                         r->netbios_name = NULL;
7687                 }
7688                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dns_name));
7689                 if (_ptr_dns_name) {
7690                         NDR_PULL_ALLOC(ndr, r->dns_name);
7691                 } else {
7692                         r->dns_name = NULL;
7693                 }
7694                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_name));
7695                 if (_ptr_site_name) {
7696                         NDR_PULL_ALLOC(ndr, r->site_name);
7697                 } else {
7698                         r->site_name = NULL;
7699                 }
7700                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_dn));
7701                 if (_ptr_site_dn) {
7702                         NDR_PULL_ALLOC(ndr, r->site_dn);
7703                 } else {
7704                         r->site_dn = NULL;
7705                 }
7706                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_computer_dn));
7707                 if (_ptr_computer_dn) {
7708                         NDR_PULL_ALLOC(ndr, r->computer_dn);
7709                 } else {
7710                         r->computer_dn = NULL;
7711                 }
7712                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_dn));
7713                 if (_ptr_server_dn) {
7714                         NDR_PULL_ALLOC(ndr, r->server_dn);
7715                 } else {
7716                         r->server_dn = NULL;
7717                 }
7718                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ntds_dn));
7719                 if (_ptr_ntds_dn) {
7720                         NDR_PULL_ALLOC(ndr, r->ntds_dn);
7721                 } else {
7722                         r->ntds_dn = NULL;
7723                 }
7724                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_pdc));
7725                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_enabled));
7726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_gc));
7727                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->is_rodc));
7728                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->site_guid));
7729                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->computer_guid));
7730                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->server_guid));
7731                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->ntds_guid));
7732                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7733         }
7734         if (ndr_flags & NDR_BUFFERS) {
7735                 if (r->netbios_name) {
7736                         _mem_save_netbios_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7737                         NDR_PULL_SET_MEM_CTX(ndr, r->netbios_name, 0);
7738                         NDR_CHECK(ndr_pull_array_size(ndr, &r->netbios_name));
7739                         NDR_CHECK(ndr_pull_array_length(ndr, &r->netbios_name));
7740                         if (ndr_get_array_length(ndr, &r->netbios_name) > ndr_get_array_size(ndr, &r->netbios_name)) {
7741                                 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));
7742                         }
7743                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t)));
7744                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->netbios_name, ndr_get_array_length(ndr, &r->netbios_name), sizeof(uint16_t), CH_UTF16));
7745                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_netbios_name_0, 0);
7746                 }
7747                 if (r->dns_name) {
7748                         _mem_save_dns_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7749                         NDR_PULL_SET_MEM_CTX(ndr, r->dns_name, 0);
7750                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dns_name));
7751                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dns_name));
7752                         if (ndr_get_array_length(ndr, &r->dns_name) > ndr_get_array_size(ndr, &r->dns_name)) {
7753                                 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));
7754                         }
7755                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t)));
7756                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->dns_name, ndr_get_array_length(ndr, &r->dns_name), sizeof(uint16_t), CH_UTF16));
7757                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dns_name_0, 0);
7758                 }
7759                 if (r->site_name) {
7760                         _mem_save_site_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7761                         NDR_PULL_SET_MEM_CTX(ndr, r->site_name, 0);
7762                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_name));
7763                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_name));
7764                         if (ndr_get_array_length(ndr, &r->site_name) > ndr_get_array_size(ndr, &r->site_name)) {
7765                                 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));
7766                         }
7767                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t)));
7768                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_name, ndr_get_array_length(ndr, &r->site_name), sizeof(uint16_t), CH_UTF16));
7769                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_name_0, 0);
7770                 }
7771                 if (r->site_dn) {
7772                         _mem_save_site_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7773                         NDR_PULL_SET_MEM_CTX(ndr, r->site_dn, 0);
7774                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_dn));
7775                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_dn));
7776                         if (ndr_get_array_length(ndr, &r->site_dn) > ndr_get_array_size(ndr, &r->site_dn)) {
7777                                 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));
7778                         }
7779                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t)));
7780                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_dn, ndr_get_array_length(ndr, &r->site_dn), sizeof(uint16_t), CH_UTF16));
7781                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_dn_0, 0);
7782                 }
7783                 if (r->computer_dn) {
7784                         _mem_save_computer_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7785                         NDR_PULL_SET_MEM_CTX(ndr, r->computer_dn, 0);
7786                         NDR_CHECK(ndr_pull_array_size(ndr, &r->computer_dn));
7787                         NDR_CHECK(ndr_pull_array_length(ndr, &r->computer_dn));
7788                         if (ndr_get_array_length(ndr, &r->computer_dn) > ndr_get_array_size(ndr, &r->computer_dn)) {
7789                                 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));
7790                         }
7791                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t)));
7792                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->computer_dn, ndr_get_array_length(ndr, &r->computer_dn), sizeof(uint16_t), CH_UTF16));
7793                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_computer_dn_0, 0);
7794                 }
7795                 if (r->server_dn) {
7796                         _mem_save_server_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7797                         NDR_PULL_SET_MEM_CTX(ndr, r->server_dn, 0);
7798                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_dn));
7799                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_dn));
7800                         if (ndr_get_array_length(ndr, &r->server_dn) > ndr_get_array_size(ndr, &r->server_dn)) {
7801                                 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));
7802                         }
7803                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t)));
7804                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_dn, ndr_get_array_length(ndr, &r->server_dn), sizeof(uint16_t), CH_UTF16));
7805                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_dn_0, 0);
7806                 }
7807                 if (r->ntds_dn) {
7808                         _mem_save_ntds_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
7809                         NDR_PULL_SET_MEM_CTX(ndr, r->ntds_dn, 0);
7810                         NDR_CHECK(ndr_pull_array_size(ndr, &r->ntds_dn));
7811                         NDR_CHECK(ndr_pull_array_length(ndr, &r->ntds_dn));
7812                         if (ndr_get_array_length(ndr, &r->ntds_dn) > ndr_get_array_size(ndr, &r->ntds_dn)) {
7813                                 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));
7814                         }
7815                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t)));
7816                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ntds_dn, ndr_get_array_length(ndr, &r->ntds_dn), sizeof(uint16_t), CH_UTF16));
7817                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ntds_dn_0, 0);
7818                 }
7819         }
7820         return NDR_ERR_SUCCESS;
7821 }
7822
7823 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfo3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfo3 *r)
7824 {
7825         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfo3");
7826         ndr->depth++;
7827         ndr_print_ptr(ndr, "netbios_name", r->netbios_name);
7828         ndr->depth++;
7829         if (r->netbios_name) {
7830                 ndr_print_string(ndr, "netbios_name", r->netbios_name);
7831         }
7832         ndr->depth--;
7833         ndr_print_ptr(ndr, "dns_name", r->dns_name);
7834         ndr->depth++;
7835         if (r->dns_name) {
7836                 ndr_print_string(ndr, "dns_name", r->dns_name);
7837         }
7838         ndr->depth--;
7839         ndr_print_ptr(ndr, "site_name", r->site_name);
7840         ndr->depth++;
7841         if (r->site_name) {
7842                 ndr_print_string(ndr, "site_name", r->site_name);
7843         }
7844         ndr->depth--;
7845         ndr_print_ptr(ndr, "site_dn", r->site_dn);
7846         ndr->depth++;
7847         if (r->site_dn) {
7848                 ndr_print_string(ndr, "site_dn", r->site_dn);
7849         }
7850         ndr->depth--;
7851         ndr_print_ptr(ndr, "computer_dn", r->computer_dn);
7852         ndr->depth++;
7853         if (r->computer_dn) {
7854                 ndr_print_string(ndr, "computer_dn", r->computer_dn);
7855         }
7856         ndr->depth--;
7857         ndr_print_ptr(ndr, "server_dn", r->server_dn);
7858         ndr->depth++;
7859         if (r->server_dn) {
7860                 ndr_print_string(ndr, "server_dn", r->server_dn);
7861         }
7862         ndr->depth--;
7863         ndr_print_ptr(ndr, "ntds_dn", r->ntds_dn);
7864         ndr->depth++;
7865         if (r->ntds_dn) {
7866                 ndr_print_string(ndr, "ntds_dn", r->ntds_dn);
7867         }
7868         ndr->depth--;
7869         ndr_print_uint32(ndr, "is_pdc", r->is_pdc);
7870         ndr_print_uint32(ndr, "is_enabled", r->is_enabled);
7871         ndr_print_uint32(ndr, "is_gc", r->is_gc);
7872         ndr_print_uint32(ndr, "is_rodc", r->is_rodc);
7873         ndr_print_GUID(ndr, "site_guid", &r->site_guid);
7874         ndr_print_GUID(ndr, "computer_guid", &r->computer_guid);
7875         ndr_print_GUID(ndr, "server_guid", &r->server_guid);
7876         ndr_print_GUID(ndr, "ntds_guid", &r->ntds_guid);
7877         ndr->depth--;
7878 }
7879
7880 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCInfoCtr3 *r)
7881 {
7882         uint32_t cntr_array_1;
7883         if (ndr_flags & NDR_SCALARS) {
7884                 NDR_CHECK(ndr_push_align(ndr, 5));
7885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
7886                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
7887                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7888         }
7889         if (ndr_flags & NDR_BUFFERS) {
7890                 if (r->array) {
7891                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
7892                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7893                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7894                         }
7895                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7896                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7897                         }
7898                 }
7899         }
7900         return NDR_ERR_SUCCESS;
7901 }
7902
7903 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCInfoCtr3 *r)
7904 {
7905         uint32_t _ptr_array;
7906         uint32_t cntr_array_1;
7907         TALLOC_CTX *_mem_save_array_0;
7908         TALLOC_CTX *_mem_save_array_1;
7909         if (ndr_flags & NDR_SCALARS) {
7910                 NDR_CHECK(ndr_pull_align(ndr, 5));
7911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
7912                 if (r->count > 10000) {
7913                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
7914                 }
7915                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
7916                 if (_ptr_array) {
7917                         NDR_PULL_ALLOC(ndr, r->array);
7918                 } else {
7919                         r->array = NULL;
7920                 }
7921                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
7922         }
7923         if (ndr_flags & NDR_BUFFERS) {
7924                 if (r->array) {
7925                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
7926                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7927                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
7928                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
7929                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
7930                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
7931                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7932                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
7933                         }
7934                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
7935                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfo3(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
7936                         }
7937                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
7938                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
7939                 }
7940                 if (r->array) {
7941                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
7942                 }
7943         }
7944         return NDR_ERR_SUCCESS;
7945 }
7946
7947 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCInfoCtr3 *r)
7948 {
7949         uint32_t cntr_array_1;
7950         ndr_print_struct(ndr, name, "drsuapi_DsGetDCInfoCtr3");
7951         ndr->depth++;
7952         ndr_print_uint32(ndr, "count", r->count);
7953         ndr_print_ptr(ndr, "array", r->array);
7954         ndr->depth++;
7955         if (r->array) {
7956                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
7957                 ndr->depth++;
7958                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
7959                         char *idx_1=NULL;
7960                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
7961                                 ndr_print_drsuapi_DsGetDCInfo3(ndr, "array", &r->array[cntr_array_1]);
7962                                 free(idx_1);
7963                         }
7964                 }
7965                 ndr->depth--;
7966         }
7967         ndr->depth--;
7968         ndr->depth--;
7969 }
7970
7971 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnection01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnection01 *r)
7972 {
7973         if (ndr_flags & NDR_SCALARS) {
7974                 NDR_CHECK(ndr_push_align(ndr, 5));
7975                 {
7976                         uint32_t _flags_save_ipv4address = ndr->flags;
7977                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
7978                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
7979                         ndr->flags = _flags_save_ipv4address;
7980                 }
7981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
7982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->connection_time));
7983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown4));
7984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown5));
7985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown6));
7986                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client_account));
7987                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
7988         }
7989         if (ndr_flags & NDR_BUFFERS) {
7990                 if (r->client_account) {
7991                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7992                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
7993                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->client_account, CH_UTF16)));
7994                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client_account, ndr_charset_length(r->client_account, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7995                 }
7996         }
7997         return NDR_ERR_SUCCESS;
7998 }
7999
8000 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnection01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnection01 *r)
8001 {
8002         uint32_t _ptr_client_account;
8003         TALLOC_CTX *_mem_save_client_account_0;
8004         if (ndr_flags & NDR_SCALARS) {
8005                 NDR_CHECK(ndr_pull_align(ndr, 5));
8006                 {
8007                         uint32_t _flags_save_ipv4address = ndr->flags;
8008                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
8009                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
8010                         ndr->flags = _flags_save_ipv4address;
8011                 }
8012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8013                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->connection_time));
8014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown4));
8015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown5));
8016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown6));
8017                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client_account));
8018                 if (_ptr_client_account) {
8019                         NDR_PULL_ALLOC(ndr, r->client_account);
8020                 } else {
8021                         r->client_account = NULL;
8022                 }
8023                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8024         }
8025         if (ndr_flags & NDR_BUFFERS) {
8026                 if (r->client_account) {
8027                         _mem_save_client_account_0 = NDR_PULL_GET_MEM_CTX(ndr);
8028                         NDR_PULL_SET_MEM_CTX(ndr, r->client_account, 0);
8029                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client_account));
8030                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client_account));
8031                         if (ndr_get_array_length(ndr, &r->client_account) > ndr_get_array_size(ndr, &r->client_account)) {
8032                                 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));
8033                         }
8034                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t)));
8035                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client_account, ndr_get_array_length(ndr, &r->client_account), sizeof(uint16_t), CH_UTF16));
8036                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_account_0, 0);
8037                 }
8038         }
8039         return NDR_ERR_SUCCESS;
8040 }
8041
8042 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnection01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnection01 *r)
8043 {
8044         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnection01");
8045         ndr->depth++;
8046         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
8047         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8048         ndr_print_uint32(ndr, "connection_time", r->connection_time);
8049         ndr_print_uint32(ndr, "unknown4", r->unknown4);
8050         ndr_print_uint32(ndr, "unknown5", r->unknown5);
8051         ndr_print_uint32(ndr, "unknown6", r->unknown6);
8052         ndr_print_ptr(ndr, "client_account", r->client_account);
8053         ndr->depth++;
8054         if (r->client_account) {
8055                 ndr_print_string(ndr, "client_account", r->client_account);
8056         }
8057         ndr->depth--;
8058         ndr->depth--;
8059 }
8060
8061 static enum ndr_err_code ndr_push_drsuapi_DsGetDCConnectionCtr01(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8062 {
8063         uint32_t cntr_array_1;
8064         if (ndr_flags & NDR_SCALARS) {
8065                 NDR_CHECK(ndr_push_align(ndr, 5));
8066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8067                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->array));
8068                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8069         }
8070         if (ndr_flags & NDR_BUFFERS) {
8071                 if (r->array) {
8072                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
8073                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8074                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8075                         }
8076                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8077                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8078                         }
8079                 }
8080         }
8081         return NDR_ERR_SUCCESS;
8082 }
8083
8084 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCConnectionCtr01(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetDCConnectionCtr01 *r)
8085 {
8086         uint32_t _ptr_array;
8087         uint32_t cntr_array_1;
8088         TALLOC_CTX *_mem_save_array_0;
8089         TALLOC_CTX *_mem_save_array_1;
8090         if (ndr_flags & NDR_SCALARS) {
8091                 NDR_CHECK(ndr_pull_align(ndr, 5));
8092                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8093                 if (r->count > 10000) {
8094                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8095                 }
8096                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_array));
8097                 if (_ptr_array) {
8098                         NDR_PULL_ALLOC(ndr, r->array);
8099                 } else {
8100                         r->array = NULL;
8101                 }
8102                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8103         }
8104         if (ndr_flags & NDR_BUFFERS) {
8105                 if (r->array) {
8106                         _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
8107                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8108                         NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
8109                         NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
8110                         _mem_save_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
8111                         NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
8112                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8113                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_SCALARS, &r->array[cntr_array_1]));
8114                         }
8115                         for (cntr_array_1 = 0; cntr_array_1 < r->count; cntr_array_1++) {
8116                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnection01(ndr, NDR_BUFFERS, &r->array[cntr_array_1]));
8117                         }
8118                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_1, 0);
8119                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
8120                 }
8121                 if (r->array) {
8122                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
8123                 }
8124         }
8125         return NDR_ERR_SUCCESS;
8126 }
8127
8128 _PUBLIC_ void ndr_print_drsuapi_DsGetDCConnectionCtr01(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetDCConnectionCtr01 *r)
8129 {
8130         uint32_t cntr_array_1;
8131         ndr_print_struct(ndr, name, "drsuapi_DsGetDCConnectionCtr01");
8132         ndr->depth++;
8133         ndr_print_uint32(ndr, "count", r->count);
8134         ndr_print_ptr(ndr, "array", r->array);
8135         ndr->depth++;
8136         if (r->array) {
8137                 ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
8138                 ndr->depth++;
8139                 for (cntr_array_1=0;cntr_array_1<r->count;cntr_array_1++) {
8140                         char *idx_1=NULL;
8141                         if (asprintf(&idx_1, "[%d]", cntr_array_1) != -1) {
8142                                 ndr_print_drsuapi_DsGetDCConnection01(ndr, "array", &r->array[cntr_array_1]);
8143                                 free(idx_1);
8144                         }
8145                 }
8146                 ndr->depth--;
8147         }
8148         ndr->depth--;
8149         ndr->depth--;
8150 }
8151
8152 static enum ndr_err_code ndr_push_drsuapi_DsGetDCInfoCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetDCInfoCtr *r)
8153 {
8154         if (ndr_flags & NDR_SCALARS) {
8155                 int level = ndr_push_get_switch_value(ndr, r);
8156                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8157                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8158                 switch (level) {
8159                         case DRSUAPI_DC_INFO_CTR_1: {
8160                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8161                         break; }
8162
8163                         case DRSUAPI_DC_INFO_CTR_2: {
8164                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8165                         break; }
8166
8167                         case DRSUAPI_DC_INFO_CTR_3: {
8168                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8169                         break; }
8170
8171                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8172                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8173                         break; }
8174
8175                         default:
8176                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8177                 }
8178         }
8179         if (ndr_flags & NDR_BUFFERS) {
8180                 int level = ndr_push_get_switch_value(ndr, r);
8181                 switch (level) {
8182                         case DRSUAPI_DC_INFO_CTR_1:
8183                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8184                         break;
8185
8186                         case DRSUAPI_DC_INFO_CTR_2:
8187                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8188                         break;
8189
8190                         case DRSUAPI_DC_INFO_CTR_3:
8191                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8192                         break;
8193
8194                         case DRSUAPI_DC_CONNECTION_CTR_01:
8195                                 NDR_CHECK(ndr_push_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8196                         break;
8197
8198                         default:
8199                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8200                 }
8201         }
8202         return NDR_ERR_SUCCESS;
8203 }
8204
8205 static enum ndr_err_code ndr_pull_drsuapi_DsGetDCInfoCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetDCInfoCtr *r)
8206 {
8207         int level;
8208         int32_t _level;
8209         level = ndr_pull_get_switch_value(ndr, r);
8210         if (ndr_flags & NDR_SCALARS) {
8211                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8212                 if (_level != level) {
8213                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8214                 }
8215                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8216                 switch (level) {
8217                         case DRSUAPI_DC_INFO_CTR_1: {
8218                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_SCALARS, &r->ctr1));
8219                         break; }
8220
8221                         case DRSUAPI_DC_INFO_CTR_2: {
8222                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_SCALARS, &r->ctr2));
8223                         break; }
8224
8225                         case DRSUAPI_DC_INFO_CTR_3: {
8226                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_SCALARS, &r->ctr3));
8227                         break; }
8228
8229                         case DRSUAPI_DC_CONNECTION_CTR_01: {
8230                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_SCALARS, &r->ctr01));
8231                         break; }
8232
8233                         default:
8234                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8235                 }
8236         }
8237         if (ndr_flags & NDR_BUFFERS) {
8238                 switch (level) {
8239                         case DRSUAPI_DC_INFO_CTR_1:
8240                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr1(ndr, NDR_BUFFERS, &r->ctr1));
8241                         break;
8242
8243                         case DRSUAPI_DC_INFO_CTR_2:
8244                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr2(ndr, NDR_BUFFERS, &r->ctr2));
8245                         break;
8246
8247                         case DRSUAPI_DC_INFO_CTR_3:
8248                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr3(ndr, NDR_BUFFERS, &r->ctr3));
8249                         break;
8250
8251                         case DRSUAPI_DC_CONNECTION_CTR_01:
8252                                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCConnectionCtr01(ndr, NDR_BUFFERS, &r->ctr01));
8253                         break;
8254
8255                         default:
8256                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8257                 }
8258         }
8259         return NDR_ERR_SUCCESS;
8260 }
8261
8262 _PUBLIC_ void ndr_print_drsuapi_DsGetDCInfoCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetDCInfoCtr *r)
8263 {
8264         int level;
8265         level = ndr_print_get_switch_value(ndr, r);
8266         ndr_print_union(ndr, name, level, "drsuapi_DsGetDCInfoCtr");
8267         switch (level) {
8268                 case DRSUAPI_DC_INFO_CTR_1:
8269                         ndr_print_drsuapi_DsGetDCInfoCtr1(ndr, "ctr1", &r->ctr1);
8270                 break;
8271
8272                 case DRSUAPI_DC_INFO_CTR_2:
8273                         ndr_print_drsuapi_DsGetDCInfoCtr2(ndr, "ctr2", &r->ctr2);
8274                 break;
8275
8276                 case DRSUAPI_DC_INFO_CTR_3:
8277                         ndr_print_drsuapi_DsGetDCInfoCtr3(ndr, "ctr3", &r->ctr3);
8278                 break;
8279
8280                 case DRSUAPI_DC_CONNECTION_CTR_01:
8281                         ndr_print_drsuapi_DsGetDCConnectionCtr01(ndr, "ctr01", &r->ctr01);
8282                 break;
8283
8284                 default:
8285                         ndr_print_bad_level(ndr, name, level);
8286         }
8287 }
8288
8289 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectListItem(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectListItem *r)
8290 {
8291         if (ndr_flags & NDR_SCALARS) {
8292                 NDR_CHECK(ndr_push_align(ndr, 5));
8293                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next_object));
8294                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8295                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8296         }
8297         if (ndr_flags & NDR_BUFFERS) {
8298                 if (r->next_object) {
8299                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8300                 }
8301                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8302         }
8303         return NDR_ERR_SUCCESS;
8304 }
8305
8306 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectListItem(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectListItem *r)
8307 {
8308         uint32_t _ptr_next_object;
8309         TALLOC_CTX *_mem_save_next_object_0;
8310         if (ndr_flags & NDR_SCALARS) {
8311                 NDR_CHECK(ndr_pull_align(ndr, 5));
8312                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next_object));
8313                 if (_ptr_next_object) {
8314                         NDR_PULL_ALLOC(ndr, r->next_object);
8315                 } else {
8316                         r->next_object = NULL;
8317                 }
8318                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_SCALARS, &r->object));
8319                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8320         }
8321         if (ndr_flags & NDR_BUFFERS) {
8322                 if (r->next_object) {
8323                         _mem_save_next_object_0 = NDR_PULL_GET_MEM_CTX(ndr);
8324                         NDR_PULL_SET_MEM_CTX(ndr, r->next_object, 0);
8325                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS|NDR_BUFFERS, r->next_object));
8326                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_object_0, 0);
8327                 }
8328                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObject(ndr, NDR_BUFFERS, &r->object));
8329         }
8330         return NDR_ERR_SUCCESS;
8331 }
8332
8333 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryRequest2 *r)
8334 {
8335         if (ndr_flags & NDR_SCALARS) {
8336                 NDR_CHECK(ndr_push_align(ndr, 5));
8337                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8338                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8339         }
8340         if (ndr_flags & NDR_BUFFERS) {
8341                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8342         }
8343         return NDR_ERR_SUCCESS;
8344 }
8345
8346 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryRequest2 *r)
8347 {
8348         if (ndr_flags & NDR_SCALARS) {
8349                 NDR_CHECK(ndr_pull_align(ndr, 5));
8350                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_SCALARS, &r->first_object));
8351                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8352         }
8353         if (ndr_flags & NDR_BUFFERS) {
8354                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectListItem(ndr, NDR_BUFFERS, &r->first_object));
8355         }
8356         return NDR_ERR_SUCCESS;
8357 }
8358
8359 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryRequest2 *r)
8360 {
8361         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryRequest2");
8362         ndr->depth++;
8363         ndr_print_drsuapi_DsReplicaObjectListItem(ndr, "first_object", &r->first_object);
8364         ndr->depth--;
8365 }
8366
8367 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryRequest *r)
8368 {
8369         if (ndr_flags & NDR_SCALARS) {
8370                 int level = ndr_push_get_switch_value(ndr, r);
8371                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
8372                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8373                 switch (level) {
8374                         case 2: {
8375                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8376                         break; }
8377
8378                         default:
8379                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8380                 }
8381         }
8382         if (ndr_flags & NDR_BUFFERS) {
8383                 int level = ndr_push_get_switch_value(ndr, r);
8384                 switch (level) {
8385                         case 2:
8386                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8387                         break;
8388
8389                         default:
8390                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8391                 }
8392         }
8393         return NDR_ERR_SUCCESS;
8394 }
8395
8396 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryRequest *r)
8397 {
8398         int level;
8399         int32_t _level;
8400         level = ndr_pull_get_switch_value(ndr, r);
8401         if (ndr_flags & NDR_SCALARS) {
8402                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
8403                 if (_level != level) {
8404                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8405                 }
8406                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8407                 switch (level) {
8408                         case 2: {
8409                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_SCALARS, &r->req2));
8410                         break; }
8411
8412                         default:
8413                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8414                 }
8415         }
8416         if (ndr_flags & NDR_BUFFERS) {
8417                 switch (level) {
8418                         case 2:
8419                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest2(ndr, NDR_BUFFERS, &r->req2));
8420                         break;
8421
8422                         default:
8423                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8424                 }
8425         }
8426         return NDR_ERR_SUCCESS;
8427 }
8428
8429 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryRequest *r)
8430 {
8431         int level;
8432         level = ndr_print_get_switch_value(ndr, r);
8433         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryRequest");
8434         switch (level) {
8435                 case 2:
8436                         ndr_print_drsuapi_DsAddEntryRequest2(ndr, "req2", &r->req2);
8437                 break;
8438
8439                 default:
8440                         ndr_print_bad_level(ndr, name, level);
8441         }
8442 }
8443
8444 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfoX(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfoX *r)
8445 {
8446         if (ndr_flags & NDR_SCALARS) {
8447                 NDR_CHECK(ndr_push_align(ndr, 4));
8448                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
8449                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8451                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown3));
8452                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
8453         }
8454         if (ndr_flags & NDR_BUFFERS) {
8455         }
8456         return NDR_ERR_SUCCESS;
8457 }
8458
8459 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfoX(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfoX *r)
8460 {
8461         if (ndr_flags & NDR_SCALARS) {
8462                 NDR_CHECK(ndr_pull_align(ndr, 4));
8463                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
8464                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8466                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown3));
8467                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
8468         }
8469         if (ndr_flags & NDR_BUFFERS) {
8470         }
8471         return NDR_ERR_SUCCESS;
8472 }
8473
8474 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfoX(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfoX *r)
8475 {
8476         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfoX");
8477         ndr->depth++;
8478         ndr_print_uint32(ndr, "unknown1", r->unknown1);
8479         ndr_print_WERROR(ndr, "status", r->status);
8480         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8481         ndr_print_uint16(ndr, "unknown3", r->unknown3);
8482         ndr->depth--;
8483 }
8484
8485 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8486 {
8487         if (ndr_flags & NDR_SCALARS) {
8488                 NDR_CHECK(ndr_push_align(ndr, 5));
8489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8490                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
8491                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8492         }
8493         if (ndr_flags & NDR_BUFFERS) {
8494                 if (r->data) {
8495                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->size));
8496                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->data, r->size));
8497                 }
8498         }
8499         return NDR_ERR_SUCCESS;
8500 }
8501
8502 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8503 {
8504         uint32_t _ptr_data;
8505         TALLOC_CTX *_mem_save_data_0;
8506         if (ndr_flags & NDR_SCALARS) {
8507                 NDR_CHECK(ndr_pull_align(ndr, 5));
8508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8509                 if (r->size > 10485760) {
8510                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
8511                 }
8512                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
8513                 if (_ptr_data) {
8514                         NDR_PULL_ALLOC(ndr, r->data);
8515                 } else {
8516                         r->data = NULL;
8517                 }
8518                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8519         }
8520         if (ndr_flags & NDR_BUFFERS) {
8521                 if (r->data) {
8522                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
8523                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
8524                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data));
8525                         NDR_PULL_ALLOC_N(ndr, r->data, ndr_get_array_size(ndr, &r->data));
8526                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->data, ndr_get_array_size(ndr, &r->data)));
8527                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
8528                 }
8529                 if (r->data) {
8530                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->data, r->size));
8531                 }
8532         }
8533         return NDR_ERR_SUCCESS;
8534 }
8535
8536 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraErrorBuffer *r)
8537 {
8538         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraErrorBuffer");
8539         ndr->depth++;
8540         ndr_print_uint32(ndr, "size", r->size);
8541         ndr_print_ptr(ndr, "data", r->data);
8542         ndr->depth++;
8543         if (r->data) {
8544                 ndr_print_array_uint8(ndr, "data", r->data, r->size);
8545         }
8546         ndr->depth--;
8547         ndr->depth--;
8548 }
8549
8550 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryExtraError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryExtraError1 *r)
8551 {
8552         if (ndr_flags & NDR_SCALARS) {
8553                 NDR_CHECK(ndr_push_align(ndr, 5));
8554                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8555                 NDR_CHECK(ndr_push_drsuapi_DsAttributeId(ndr, NDR_SCALARS, r->attid));
8556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
8557                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8558                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8559         }
8560         if (ndr_flags & NDR_BUFFERS) {
8561                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8562         }
8563         return NDR_ERR_SUCCESS;
8564 }
8565
8566 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryExtraError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryExtraError1 *r)
8567 {
8568         if (ndr_flags & NDR_SCALARS) {
8569                 NDR_CHECK(ndr_pull_align(ndr, 5));
8570                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
8571                 NDR_CHECK(ndr_pull_drsuapi_DsAttributeId(ndr, NDR_SCALARS, &r->attid));
8572                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
8573                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_SCALARS, &r->buffer));
8574                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8575         }
8576         if (ndr_flags & NDR_BUFFERS) {
8577                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraErrorBuffer(ndr, NDR_BUFFERS, &r->buffer));
8578         }
8579         return NDR_ERR_SUCCESS;
8580 }
8581
8582 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryExtraError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryExtraError1 *r)
8583 {
8584         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryExtraError1");
8585         ndr->depth++;
8586         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
8587         ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
8588         ndr_print_uint32(ndr, "unknown2", r->unknown2);
8589         ndr_print_drsuapi_DsAddEntryExtraErrorBuffer(ndr, "buffer", &r->buffer);
8590         ndr->depth--;
8591 }
8592
8593 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorListItem1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8594 {
8595         if (ndr_flags & NDR_SCALARS) {
8596                 NDR_CHECK(ndr_push_align(ndr, 5));
8597                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->next));
8598                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8599                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8600         }
8601         if (ndr_flags & NDR_BUFFERS) {
8602                 if (r->next) {
8603                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8604                 }
8605                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8606         }
8607         return NDR_ERR_SUCCESS;
8608 }
8609
8610 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorListItem1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorListItem1 *r)
8611 {
8612         uint32_t _ptr_next;
8613         TALLOC_CTX *_mem_save_next_0;
8614         if (ndr_flags & NDR_SCALARS) {
8615                 NDR_CHECK(ndr_pull_align(ndr, 5));
8616                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_next));
8617                 if (_ptr_next) {
8618                         NDR_PULL_ALLOC(ndr, r->next);
8619                 } else {
8620                         r->next = NULL;
8621                 }
8622                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_SCALARS, &r->error));
8623                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8624         }
8625         if (ndr_flags & NDR_BUFFERS) {
8626                 if (r->next) {
8627                         _mem_save_next_0 = NDR_PULL_GET_MEM_CTX(ndr);
8628                         NDR_PULL_SET_MEM_CTX(ndr, r->next, 0);
8629                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS|NDR_BUFFERS, r->next));
8630                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_next_0, 0);
8631                 }
8632                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryExtraError1(ndr, NDR_BUFFERS, &r->error));
8633         }
8634         return NDR_ERR_SUCCESS;
8635 }
8636
8637 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorListItem1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorListItem1 *r)
8638 {
8639         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorListItem1");
8640         ndr->depth++;
8641         ndr_print_ptr(ndr, "next", r->next);
8642         ndr->depth++;
8643         if (r->next) {
8644                 ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "next", r->next);
8645         }
8646         ndr->depth--;
8647         ndr_print_drsuapi_DsAddEntryExtraError1(ndr, "error", &r->error);
8648         ndr->depth--;
8649 }
8650
8651 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8652 {
8653         if (ndr_flags & NDR_SCALARS) {
8654                 NDR_CHECK(ndr_push_align(ndr, 5));
8655                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
8656                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8657                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8658                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8659         }
8660         if (ndr_flags & NDR_BUFFERS) {
8661                 if (r->id) {
8662                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8663                 }
8664                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8665         }
8666         return NDR_ERR_SUCCESS;
8667 }
8668
8669 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryErrorInfo1 *r)
8670 {
8671         uint32_t _ptr_id;
8672         TALLOC_CTX *_mem_save_id_0;
8673         if (ndr_flags & NDR_SCALARS) {
8674                 NDR_CHECK(ndr_pull_align(ndr, 5));
8675                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
8676                 if (_ptr_id) {
8677                         NDR_PULL_ALLOC(ndr, r->id);
8678                 } else {
8679                         r->id = NULL;
8680                 }
8681                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8682                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_SCALARS, &r->first));
8683                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8684         }
8685         if (ndr_flags & NDR_BUFFERS) {
8686                 if (r->id) {
8687                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8688                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
8689                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
8690                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
8691                 }
8692                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorListItem1(ndr, NDR_BUFFERS, &r->first));
8693         }
8694         return NDR_ERR_SUCCESS;
8695 }
8696
8697 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryErrorInfo1 *r)
8698 {
8699         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryErrorInfo1");
8700         ndr->depth++;
8701         ndr_print_ptr(ndr, "id", r->id);
8702         ndr->depth++;
8703         if (r->id) {
8704                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
8705         }
8706         ndr->depth--;
8707         ndr_print_WERROR(ndr, "status", r->status);
8708         ndr_print_drsuapi_DsAddEntryErrorListItem1(ndr, "first", &r->first);
8709         ndr->depth--;
8710 }
8711
8712 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryErrorInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryErrorInfo *r)
8713 {
8714         if (ndr_flags & NDR_SCALARS) {
8715                 int level = ndr_push_get_switch_value(ndr, r);
8716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8717                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8718                 switch (level) {
8719                         case 1: {
8720                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8721                         break; }
8722
8723                         case 4: {
8724                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8725                         break; }
8726
8727                         case 5: {
8728                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8729                         break; }
8730
8731                         case 6: {
8732                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8733                         break; }
8734
8735                         case 7: {
8736                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8737                         break; }
8738
8739                         default:
8740                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8741                 }
8742         }
8743         if (ndr_flags & NDR_BUFFERS) {
8744                 int level = ndr_push_get_switch_value(ndr, r);
8745                 switch (level) {
8746                         case 1:
8747                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8748                         break;
8749
8750                         case 4:
8751                         break;
8752
8753                         case 5:
8754                         break;
8755
8756                         case 6:
8757                         break;
8758
8759                         case 7:
8760                         break;
8761
8762                         default:
8763                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8764                 }
8765         }
8766         return NDR_ERR_SUCCESS;
8767 }
8768
8769 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryErrorInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryErrorInfo *r)
8770 {
8771         int level;
8772         uint32_t _level;
8773         level = ndr_pull_get_switch_value(ndr, r);
8774         if (ndr_flags & NDR_SCALARS) {
8775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8776                 if (_level != level) {
8777                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8778                 }
8779                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8780                 switch (level) {
8781                         case 1: {
8782                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_SCALARS, &r->error1));
8783                         break; }
8784
8785                         case 4: {
8786                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8787                         break; }
8788
8789                         case 5: {
8790                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8791                         break; }
8792
8793                         case 6: {
8794                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8795                         break; }
8796
8797                         case 7: {
8798                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->errorX));
8799                         break; }
8800
8801                         default:
8802                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8803                 }
8804         }
8805         if (ndr_flags & NDR_BUFFERS) {
8806                 switch (level) {
8807                         case 1:
8808                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo1(ndr, NDR_BUFFERS, &r->error1));
8809                         break;
8810
8811                         case 4:
8812                         break;
8813
8814                         case 5:
8815                         break;
8816
8817                         case 6:
8818                         break;
8819
8820                         case 7:
8821                         break;
8822
8823                         default:
8824                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8825                 }
8826         }
8827         return NDR_ERR_SUCCESS;
8828 }
8829
8830 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryErrorInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryErrorInfo *r)
8831 {
8832         int level;
8833         level = ndr_print_get_switch_value(ndr, r);
8834         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryErrorInfo");
8835         switch (level) {
8836                 case 1:
8837                         ndr_print_drsuapi_DsAddEntryErrorInfo1(ndr, "error1", &r->error1);
8838                 break;
8839
8840                 case 4:
8841                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8842                 break;
8843
8844                 case 5:
8845                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8846                 break;
8847
8848                 case 6:
8849                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8850                 break;
8851
8852                 case 7:
8853                         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "errorX", &r->errorX);
8854                 break;
8855
8856                 default:
8857                         ndr_print_bad_level(ndr, name, level);
8858         }
8859 }
8860
8861 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryError1 *r)
8862 {
8863         if (ndr_flags & NDR_SCALARS) {
8864                 NDR_CHECK(ndr_push_align(ndr, 5));
8865                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->status));
8866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8867                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
8868                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
8869         }
8870         if (ndr_flags & NDR_BUFFERS) {
8871                 if (r->info) {
8872                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->info, r->level));
8873                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8874                 }
8875         }
8876         return NDR_ERR_SUCCESS;
8877 }
8878
8879 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryError1 *r)
8880 {
8881         uint32_t _ptr_info;
8882         TALLOC_CTX *_mem_save_info_0;
8883         if (ndr_flags & NDR_SCALARS) {
8884                 NDR_CHECK(ndr_pull_align(ndr, 5));
8885                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->status));
8886                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8887                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
8888                 if (_ptr_info) {
8889                         NDR_PULL_ALLOC(ndr, r->info);
8890                 } else {
8891                         r->info = NULL;
8892                 }
8893                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
8894         }
8895         if (ndr_flags & NDR_BUFFERS) {
8896                 if (r->info) {
8897                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
8898                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
8899                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->info, r->level));
8900                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info));
8901                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
8902                 }
8903         }
8904         return NDR_ERR_SUCCESS;
8905 }
8906
8907 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryError1 *r)
8908 {
8909         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryError1");
8910         ndr->depth++;
8911         ndr_print_WERROR(ndr, "status", r->status);
8912         ndr_print_uint32(ndr, "level", r->level);
8913         ndr_print_ptr(ndr, "info", r->info);
8914         ndr->depth++;
8915         if (r->info) {
8916                 ndr_print_set_switch_value(ndr, r->info, r->level);
8917                 ndr_print_drsuapi_DsAddEntryErrorInfo(ndr, "info", r->info);
8918         }
8919         ndr->depth--;
8920         ndr->depth--;
8921 }
8922
8923 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryError(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryError *r)
8924 {
8925         if (ndr_flags & NDR_SCALARS) {
8926                 int level = ndr_push_get_switch_value(ndr, r);
8927                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8928                 NDR_CHECK(ndr_push_union_align(ndr, 5));
8929                 switch (level) {
8930                         case 1: {
8931                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8932                         break; }
8933
8934                         default:
8935                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8936                 }
8937         }
8938         if (ndr_flags & NDR_BUFFERS) {
8939                 int level = ndr_push_get_switch_value(ndr, r);
8940                 switch (level) {
8941                         case 1:
8942                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8943                         break;
8944
8945                         default:
8946                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8947                 }
8948         }
8949         return NDR_ERR_SUCCESS;
8950 }
8951
8952 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryError(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryError *r)
8953 {
8954         int level;
8955         uint32_t _level;
8956         level = ndr_pull_get_switch_value(ndr, r);
8957         if (ndr_flags & NDR_SCALARS) {
8958                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8959                 if (_level != level) {
8960                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
8961                 }
8962                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
8963                 switch (level) {
8964                         case 1: {
8965                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_SCALARS, &r->info1));
8966                         break; }
8967
8968                         default:
8969                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8970                 }
8971         }
8972         if (ndr_flags & NDR_BUFFERS) {
8973                 switch (level) {
8974                         case 1:
8975                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError1(ndr, NDR_BUFFERS, &r->info1));
8976                         break;
8977
8978                         default:
8979                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
8980                 }
8981         }
8982         return NDR_ERR_SUCCESS;
8983 }
8984
8985 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryError(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryError *r)
8986 {
8987         int level;
8988         level = ndr_print_get_switch_value(ndr, r);
8989         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryError");
8990         switch (level) {
8991                 case 1:
8992                         ndr_print_drsuapi_DsAddEntryError1(ndr, "info1", &r->info1);
8993                 break;
8994
8995                 default:
8996                         ndr_print_bad_level(ndr, name, level);
8997         }
8998 }
8999
9000 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjectIdentifier2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9001 {
9002         if (ndr_flags & NDR_SCALARS) {
9003                 NDR_CHECK(ndr_push_align(ndr, 4));
9004                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid));
9005                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9006                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9007         }
9008         if (ndr_flags & NDR_BUFFERS) {
9009                 NDR_CHECK(ndr_push_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9010         }
9011         return NDR_ERR_SUCCESS;
9012 }
9013
9014 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjectIdentifier2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjectIdentifier2 *r)
9015 {
9016         if (ndr_flags & NDR_SCALARS) {
9017                 NDR_CHECK(ndr_pull_align(ndr, 4));
9018                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid));
9019                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_SCALARS, &r->sid));
9020                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9021         }
9022         if (ndr_flags & NDR_BUFFERS) {
9023                 NDR_CHECK(ndr_pull_dom_sid28(ndr, NDR_BUFFERS, &r->sid));
9024         }
9025         return NDR_ERR_SUCCESS;
9026 }
9027
9028 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjectIdentifier2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjectIdentifier2 *r)
9029 {
9030         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjectIdentifier2");
9031         ndr->depth++;
9032         ndr_print_GUID(ndr, "guid", &r->guid);
9033         ndr_print_dom_sid28(ndr, "sid", &r->sid);
9034         ndr->depth--;
9035 }
9036
9037 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr2 *r)
9038 {
9039         uint32_t cntr_objects_1;
9040         if (ndr_flags & NDR_SCALARS) {
9041                 NDR_CHECK(ndr_push_align(ndr, 5));
9042                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9043                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown1));
9044                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9046                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9047                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9048         }
9049         if (ndr_flags & NDR_BUFFERS) {
9050                 if (r->id) {
9051                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9052                 }
9053                 if (r->objects) {
9054                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
9055                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9056                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9057                         }
9058                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9059                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9060                         }
9061                 }
9062         }
9063         return NDR_ERR_SUCCESS;
9064 }
9065
9066 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr2 *r)
9067 {
9068         uint32_t _ptr_id;
9069         TALLOC_CTX *_mem_save_id_0;
9070         uint32_t _ptr_objects;
9071         uint32_t cntr_objects_1;
9072         TALLOC_CTX *_mem_save_objects_0;
9073         TALLOC_CTX *_mem_save_objects_1;
9074         if (ndr_flags & NDR_SCALARS) {
9075                 NDR_CHECK(ndr_pull_align(ndr, 5));
9076                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9077                 if (_ptr_id) {
9078                         NDR_PULL_ALLOC(ndr, r->id);
9079                 } else {
9080                         r->id = NULL;
9081                 }
9082                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
9083                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryErrorInfoX(ndr, NDR_SCALARS, &r->error));
9084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9085                 if (r->count > 10000) {
9086                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9087                 }
9088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9089                 if (_ptr_objects) {
9090                         NDR_PULL_ALLOC(ndr, r->objects);
9091                 } else {
9092                         r->objects = NULL;
9093                 }
9094                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9095         }
9096         if (ndr_flags & NDR_BUFFERS) {
9097                 if (r->id) {
9098                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9099                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9100                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9101                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9102                 }
9103                 if (r->objects) {
9104                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9105                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9106                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9107                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9108                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9109                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9110                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9111                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9112                         }
9113                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9114                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9115                         }
9116                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9117                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9118                 }
9119                 if (r->objects) {
9120                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9121                 }
9122         }
9123         return NDR_ERR_SUCCESS;
9124 }
9125
9126 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr2 *r)
9127 {
9128         uint32_t cntr_objects_1;
9129         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr2");
9130         ndr->depth++;
9131         ndr_print_ptr(ndr, "id", r->id);
9132         ndr->depth++;
9133         if (r->id) {
9134                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9135         }
9136         ndr->depth--;
9137         ndr_print_uint32(ndr, "unknown1", r->unknown1);
9138         ndr_print_drsuapi_DsAddEntryErrorInfoX(ndr, "error", &r->error);
9139         ndr_print_uint32(ndr, "count", r->count);
9140         ndr_print_ptr(ndr, "objects", r->objects);
9141         ndr->depth++;
9142         if (r->objects) {
9143                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9144                 ndr->depth++;
9145                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9146                         char *idx_1=NULL;
9147                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9148                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9149                                 free(idx_1);
9150                         }
9151                 }
9152                 ndr->depth--;
9153         }
9154         ndr->depth--;
9155         ndr->depth--;
9156 }
9157
9158 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsAddEntryCtr3 *r)
9159 {
9160         uint32_t cntr_objects_1;
9161         if (ndr_flags & NDR_SCALARS) {
9162                 NDR_CHECK(ndr_push_align(ndr, 5));
9163                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->id));
9164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9165                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->error));
9166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
9167                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objects));
9168                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9169         }
9170         if (ndr_flags & NDR_BUFFERS) {
9171                 if (r->id) {
9172                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9173                 }
9174                 if (r->error) {
9175                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->error, r->level));
9176                         NDR_CHECK(ndr_push_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
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_DsAddEntryCtr3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsAddEntryCtr3 *r)
9192 {
9193         uint32_t _ptr_id;
9194         TALLOC_CTX *_mem_save_id_0;
9195         uint32_t _ptr_error;
9196         TALLOC_CTX *_mem_save_error_0;
9197         uint32_t _ptr_objects;
9198         uint32_t cntr_objects_1;
9199         TALLOC_CTX *_mem_save_objects_0;
9200         TALLOC_CTX *_mem_save_objects_1;
9201         if (ndr_flags & NDR_SCALARS) {
9202                 NDR_CHECK(ndr_pull_align(ndr, 5));
9203                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_id));
9204                 if (_ptr_id) {
9205                         NDR_PULL_ALLOC(ndr, r->id);
9206                 } else {
9207                         r->id = NULL;
9208                 }
9209                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9210                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_error));
9211                 if (_ptr_error) {
9212                         NDR_PULL_ALLOC(ndr, r->error);
9213                 } else {
9214                         r->error = NULL;
9215                 }
9216                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
9217                 if (r->count > 10000) {
9218                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
9219                 }
9220                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objects));
9221                 if (_ptr_objects) {
9222                         NDR_PULL_ALLOC(ndr, r->objects);
9223                 } else {
9224                         r->objects = NULL;
9225                 }
9226                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9227         }
9228         if (ndr_flags & NDR_BUFFERS) {
9229                 if (r->id) {
9230                         _mem_save_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9231                         NDR_PULL_SET_MEM_CTX(ndr, r->id, 0);
9232                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->id));
9233                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_id_0, 0);
9234                 }
9235                 if (r->error) {
9236                         _mem_save_error_0 = NDR_PULL_GET_MEM_CTX(ndr);
9237                         NDR_PULL_SET_MEM_CTX(ndr, r->error, 0);
9238                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->error, r->level));
9239                         NDR_CHECK(ndr_pull_drsuapi_DsAddEntryError(ndr, NDR_SCALARS|NDR_BUFFERS, r->error));
9240                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_error_0, 0);
9241                 }
9242                 if (r->objects) {
9243                         _mem_save_objects_0 = NDR_PULL_GET_MEM_CTX(ndr);
9244                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9245                         NDR_CHECK(ndr_pull_array_size(ndr, &r->objects));
9246                         NDR_PULL_ALLOC_N(ndr, r->objects, ndr_get_array_size(ndr, &r->objects));
9247                         _mem_save_objects_1 = NDR_PULL_GET_MEM_CTX(ndr);
9248                         NDR_PULL_SET_MEM_CTX(ndr, r->objects, 0);
9249                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9250                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_SCALARS, &r->objects[cntr_objects_1]));
9251                         }
9252                         for (cntr_objects_1 = 0; cntr_objects_1 < r->count; cntr_objects_1++) {
9253                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier2(ndr, NDR_BUFFERS, &r->objects[cntr_objects_1]));
9254                         }
9255                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_1, 0);
9256                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objects_0, 0);
9257                 }
9258                 if (r->objects) {
9259                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->objects, r->count));
9260                 }
9261         }
9262         return NDR_ERR_SUCCESS;
9263 }
9264
9265 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntryCtr3 *r)
9266 {
9267         uint32_t cntr_objects_1;
9268         ndr_print_struct(ndr, name, "drsuapi_DsAddEntryCtr3");
9269         ndr->depth++;
9270         ndr_print_ptr(ndr, "id", r->id);
9271         ndr->depth++;
9272         if (r->id) {
9273                 ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "id", r->id);
9274         }
9275         ndr->depth--;
9276         ndr_print_uint32(ndr, "level", r->level);
9277         ndr_print_ptr(ndr, "error", r->error);
9278         ndr->depth++;
9279         if (r->error) {
9280                 ndr_print_set_switch_value(ndr, r->error, r->level);
9281                 ndr_print_drsuapi_DsAddEntryError(ndr, "error", r->error);
9282         }
9283         ndr->depth--;
9284         ndr_print_uint32(ndr, "count", r->count);
9285         ndr_print_ptr(ndr, "objects", r->objects);
9286         ndr->depth++;
9287         if (r->objects) {
9288                 ndr->print(ndr, "%s: ARRAY(%d)", "objects", (int)r->count);
9289                 ndr->depth++;
9290                 for (cntr_objects_1=0;cntr_objects_1<r->count;cntr_objects_1++) {
9291                         char *idx_1=NULL;
9292                         if (asprintf(&idx_1, "[%d]", cntr_objects_1) != -1) {
9293                                 ndr_print_drsuapi_DsReplicaObjectIdentifier2(ndr, "objects", &r->objects[cntr_objects_1]);
9294                                 free(idx_1);
9295                         }
9296                 }
9297                 ndr->depth--;
9298         }
9299         ndr->depth--;
9300         ndr->depth--;
9301 }
9302
9303 static enum ndr_err_code ndr_push_drsuapi_DsAddEntryCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsAddEntryCtr *r)
9304 {
9305         if (ndr_flags & NDR_SCALARS) {
9306                 int level = ndr_push_get_switch_value(ndr, r);
9307                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
9308                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9309                 switch (level) {
9310                         case 2: {
9311                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9312                         break; }
9313
9314                         case 3: {
9315                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9316                         break; }
9317
9318                         default:
9319                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9320                 }
9321         }
9322         if (ndr_flags & NDR_BUFFERS) {
9323                 int level = ndr_push_get_switch_value(ndr, r);
9324                 switch (level) {
9325                         case 2:
9326                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9327                         break;
9328
9329                         case 3:
9330                                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9331                         break;
9332
9333                         default:
9334                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9335                 }
9336         }
9337         return NDR_ERR_SUCCESS;
9338 }
9339
9340 static enum ndr_err_code ndr_pull_drsuapi_DsAddEntryCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsAddEntryCtr *r)
9341 {
9342         int level;
9343         int32_t _level;
9344         level = ndr_pull_get_switch_value(ndr, r);
9345         if (ndr_flags & NDR_SCALARS) {
9346                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
9347                 if (_level != level) {
9348                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9349                 }
9350                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9351                 switch (level) {
9352                         case 2: {
9353                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_SCALARS, &r->ctr2));
9354                         break; }
9355
9356                         case 3: {
9357                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_SCALARS, &r->ctr3));
9358                         break; }
9359
9360                         default:
9361                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9362                 }
9363         }
9364         if (ndr_flags & NDR_BUFFERS) {
9365                 switch (level) {
9366                         case 2:
9367                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr2(ndr, NDR_BUFFERS, &r->ctr2));
9368                         break;
9369
9370                         case 3:
9371                                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr3(ndr, NDR_BUFFERS, &r->ctr3));
9372                         break;
9373
9374                         default:
9375                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9376                 }
9377         }
9378         return NDR_ERR_SUCCESS;
9379 }
9380
9381 _PUBLIC_ void ndr_print_drsuapi_DsAddEntryCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsAddEntryCtr *r)
9382 {
9383         int level;
9384         level = ndr_print_get_switch_value(ndr, r);
9385         ndr_print_union(ndr, name, level, "drsuapi_DsAddEntryCtr");
9386         switch (level) {
9387                 case 2:
9388                         ndr_print_drsuapi_DsAddEntryCtr2(ndr, "ctr2", &r->ctr2);
9389                 break;
9390
9391                 case 3:
9392                         ndr_print_drsuapi_DsAddEntryCtr3(ndr, "ctr3", &r->ctr3);
9393                 break;
9394
9395                 default:
9396                         ndr_print_bad_level(ndr, name, level);
9397         }
9398 }
9399
9400 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9401 {
9402         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9403         return NDR_ERR_SUCCESS;
9404 }
9405
9406 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9407 {
9408         uint32_t v;
9409         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9410         *r = v;
9411         return NDR_ERR_SUCCESS;
9412 }
9413
9414 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCFlags(struct ndr_print *ndr, const char *name, uint32_t r)
9415 {
9416         ndr_print_uint32(ndr, name, r);
9417         ndr->depth++;
9418         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION, r);
9419         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_EXECUTE_KCC_DAMPED", DRSUAPI_DS_EXECUTE_KCC_DAMPED, r);
9420         ndr->depth--;
9421 }
9422
9423 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsExecuteKCC1 *r)
9424 {
9425         if (ndr_flags & NDR_SCALARS) {
9426                 NDR_CHECK(ndr_push_align(ndr, 4));
9427                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->taskID));
9428                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, r->flags));
9429                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
9430         }
9431         if (ndr_flags & NDR_BUFFERS) {
9432         }
9433         return NDR_ERR_SUCCESS;
9434 }
9435
9436 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsExecuteKCC1 *r)
9437 {
9438         if (ndr_flags & NDR_SCALARS) {
9439                 NDR_CHECK(ndr_pull_align(ndr, 4));
9440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->taskID));
9441                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCFlags(ndr, NDR_SCALARS, &r->flags));
9442                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
9443         }
9444         if (ndr_flags & NDR_BUFFERS) {
9445         }
9446         return NDR_ERR_SUCCESS;
9447 }
9448
9449 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsExecuteKCC1 *r)
9450 {
9451         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC1");
9452         ndr->depth++;
9453         ndr_print_uint32(ndr, "taskID", r->taskID);
9454         ndr_print_drsuapi_DsExecuteKCCFlags(ndr, "flags", r->flags);
9455         ndr->depth--;
9456 }
9457
9458 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCCRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsExecuteKCCRequest *r)
9459 {
9460         if (ndr_flags & NDR_SCALARS) {
9461                 int level = ndr_push_get_switch_value(ndr, r);
9462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9463                 NDR_CHECK(ndr_push_union_align(ndr, 4));
9464                 switch (level) {
9465                         case 1: {
9466                                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9467                         break; }
9468
9469                         default:
9470                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9471                 }
9472         }
9473         if (ndr_flags & NDR_BUFFERS) {
9474                 int level = ndr_push_get_switch_value(ndr, r);
9475                 switch (level) {
9476                         case 1:
9477                         break;
9478
9479                         default:
9480                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9481                 }
9482         }
9483         return NDR_ERR_SUCCESS;
9484 }
9485
9486 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCCRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsExecuteKCCRequest *r)
9487 {
9488         int level;
9489         uint32_t _level;
9490         level = ndr_pull_get_switch_value(ndr, r);
9491         if (ndr_flags & NDR_SCALARS) {
9492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9493                 if (_level != level) {
9494                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9495                 }
9496                 NDR_CHECK(ndr_pull_union_align(ndr, 4));
9497                 switch (level) {
9498                         case 1: {
9499                                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCC1(ndr, NDR_SCALARS, &r->ctr1));
9500                         break; }
9501
9502                         default:
9503                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9504                 }
9505         }
9506         if (ndr_flags & NDR_BUFFERS) {
9507                 switch (level) {
9508                         case 1:
9509                         break;
9510
9511                         default:
9512                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9513                 }
9514         }
9515         return NDR_ERR_SUCCESS;
9516 }
9517
9518 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCCRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsExecuteKCCRequest *r)
9519 {
9520         int level;
9521         level = ndr_print_get_switch_value(ndr, r);
9522         ndr_print_union(ndr, name, level, "drsuapi_DsExecuteKCCRequest");
9523         switch (level) {
9524                 case 1:
9525                         ndr_print_drsuapi_DsExecuteKCC1(ndr, "ctr1", &r->ctr1);
9526                 break;
9527
9528                 default:
9529                         ndr_print_bad_level(ndr, name, level);
9530         }
9531 }
9532
9533 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoLevel(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel r)
9534 {
9535         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9536         return NDR_ERR_SUCCESS;
9537 }
9538
9539 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoLevel(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaGetInfoLevel *r)
9540 {
9541         uint32_t v;
9542         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9543         *r = v;
9544         return NDR_ERR_SUCCESS;
9545 }
9546
9547 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoLevel(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaGetInfoLevel r)
9548 {
9549         const char *val = NULL;
9550
9551         switch (r) {
9552                 case DRSUAPI_DS_REPLICA_GET_INFO: val = "DRSUAPI_DS_REPLICA_GET_INFO"; break;
9553                 case DRSUAPI_DS_REPLICA_GET_INFO2: val = "DRSUAPI_DS_REPLICA_GET_INFO2"; break;
9554         }
9555         ndr_print_enum(ndr, name, "ENUM", val, r);
9556 }
9557
9558 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfoType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType r)
9559 {
9560         NDR_CHECK(ndr_push_enum_uint32(ndr, NDR_SCALARS, r));
9561         return NDR_ERR_SUCCESS;
9562 }
9563
9564 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfoType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaInfoType *r)
9565 {
9566         uint32_t v;
9567         NDR_CHECK(ndr_pull_enum_uint32(ndr, NDR_SCALARS, &v));
9568         *r = v;
9569         return NDR_ERR_SUCCESS;
9570 }
9571
9572 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfoType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaInfoType r)
9573 {
9574         const char *val = NULL;
9575
9576         switch (r) {
9577                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS"; break;
9578                 case DRSUAPI_DS_REPLICA_INFO_CURSORS: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS"; break;
9579                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA"; break;
9580                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES"; break;
9581                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: val = "DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES"; break;
9582                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: val = "DRSUAPI_DS_REPLICA_INFO_PENDING_OPS"; break;
9583                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA"; break;
9584                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS2"; break;
9585                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS3"; break;
9586                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2"; break;
9587                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: val = "DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2"; break;
9588                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: val = "DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02"; break;
9589                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: val = "DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04"; break;
9590                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05: val = "DRSUAPI_DS_REPLICA_INFO_CURSORS05"; break;
9591                 case DRSUAPI_DS_REPLICA_INFO_06: val = "DRSUAPI_DS_REPLICA_INFO_06"; break;
9592         }
9593         ndr_print_enum(ndr, name, "ENUM", val, r);
9594 }
9595
9596 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9597 {
9598         if (ndr_flags & NDR_SCALARS) {
9599                 NDR_CHECK(ndr_push_align(ndr, 5));
9600                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9601                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9602                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9603                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9604         }
9605         if (ndr_flags & NDR_BUFFERS) {
9606                 if (r->object_dn) {
9607                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9608                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9609                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9610                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9611                 }
9612         }
9613         return NDR_ERR_SUCCESS;
9614 }
9615
9616 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest1 *r)
9617 {
9618         uint32_t _ptr_object_dn;
9619         TALLOC_CTX *_mem_save_object_dn_0;
9620         if (ndr_flags & NDR_SCALARS) {
9621                 NDR_CHECK(ndr_pull_align(ndr, 5));
9622                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9623                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9624                 if (_ptr_object_dn) {
9625                         NDR_PULL_ALLOC(ndr, r->object_dn);
9626                 } else {
9627                         r->object_dn = NULL;
9628                 }
9629                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9630                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9631         }
9632         if (ndr_flags & NDR_BUFFERS) {
9633                 if (r->object_dn) {
9634                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9635                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9636                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9637                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9638                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9639                                 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));
9640                         }
9641                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9642                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9643                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9644                 }
9645         }
9646         return NDR_ERR_SUCCESS;
9647 }
9648
9649 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest1 *r)
9650 {
9651         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest1");
9652         ndr->depth++;
9653         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9654         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9655         ndr->depth++;
9656         if (r->object_dn) {
9657                 ndr_print_string(ndr, "object_dn", r->object_dn);
9658         }
9659         ndr->depth--;
9660         ndr_print_GUID(ndr, "guid1", &r->guid1);
9661         ndr->depth--;
9662 }
9663
9664 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9665 {
9666         if (ndr_flags & NDR_SCALARS) {
9667                 NDR_CHECK(ndr_push_align(ndr, 5));
9668                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->info_type));
9669                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
9670                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->guid1));
9671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
9672                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string1));
9673                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string2));
9674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
9675                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
9676         }
9677         if (ndr_flags & NDR_BUFFERS) {
9678                 if (r->object_dn) {
9679                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9680                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9681                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
9682                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9683                 }
9684                 if (r->string1) {
9685                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9686                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9687                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string1, CH_UTF16)));
9688                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string1, ndr_charset_length(r->string1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9689                 }
9690                 if (r->string2) {
9691                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9692                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9693                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->string2, CH_UTF16)));
9694                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string2, ndr_charset_length(r->string2, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9695                 }
9696         }
9697         return NDR_ERR_SUCCESS;
9698 }
9699
9700 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaGetInfoRequest2 *r)
9701 {
9702         uint32_t _ptr_object_dn;
9703         TALLOC_CTX *_mem_save_object_dn_0;
9704         uint32_t _ptr_string1;
9705         TALLOC_CTX *_mem_save_string1_0;
9706         uint32_t _ptr_string2;
9707         TALLOC_CTX *_mem_save_string2_0;
9708         if (ndr_flags & NDR_SCALARS) {
9709                 NDR_CHECK(ndr_pull_align(ndr, 5));
9710                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, &r->info_type));
9711                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
9712                 if (_ptr_object_dn) {
9713                         NDR_PULL_ALLOC(ndr, r->object_dn);
9714                 } else {
9715                         r->object_dn = NULL;
9716                 }
9717                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->guid1));
9718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
9719                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string1));
9720                 if (_ptr_string1) {
9721                         NDR_PULL_ALLOC(ndr, r->string1);
9722                 } else {
9723                         r->string1 = NULL;
9724                 }
9725                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string2));
9726                 if (_ptr_string2) {
9727                         NDR_PULL_ALLOC(ndr, r->string2);
9728                 } else {
9729                         r->string2 = NULL;
9730                 }
9731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
9732                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
9733         }
9734         if (ndr_flags & NDR_BUFFERS) {
9735                 if (r->object_dn) {
9736                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
9737                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
9738                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
9739                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
9740                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
9741                                 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));
9742                         }
9743                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
9744                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
9745                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
9746                 }
9747                 if (r->string1) {
9748                         _mem_save_string1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9749                         NDR_PULL_SET_MEM_CTX(ndr, r->string1, 0);
9750                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string1));
9751                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string1));
9752                         if (ndr_get_array_length(ndr, &r->string1) > ndr_get_array_size(ndr, &r->string1)) {
9753                                 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));
9754                         }
9755                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t)));
9756                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string1, ndr_get_array_length(ndr, &r->string1), sizeof(uint16_t), CH_UTF16));
9757                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string1_0, 0);
9758                 }
9759                 if (r->string2) {
9760                         _mem_save_string2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9761                         NDR_PULL_SET_MEM_CTX(ndr, r->string2, 0);
9762                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string2));
9763                         NDR_CHECK(ndr_pull_array_length(ndr, &r->string2));
9764                         if (ndr_get_array_length(ndr, &r->string2) > ndr_get_array_size(ndr, &r->string2)) {
9765                                 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));
9766                         }
9767                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t)));
9768                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string2, ndr_get_array_length(ndr, &r->string2), sizeof(uint16_t), CH_UTF16));
9769                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string2_0, 0);
9770                 }
9771         }
9772         return NDR_ERR_SUCCESS;
9773 }
9774
9775 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaGetInfoRequest2 *r)
9776 {
9777         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfoRequest2");
9778         ndr->depth++;
9779         ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", r->info_type);
9780         ndr_print_ptr(ndr, "object_dn", r->object_dn);
9781         ndr->depth++;
9782         if (r->object_dn) {
9783                 ndr_print_string(ndr, "object_dn", r->object_dn);
9784         }
9785         ndr->depth--;
9786         ndr_print_GUID(ndr, "guid1", &r->guid1);
9787         ndr_print_uint32(ndr, "flags", r->flags);
9788         ndr_print_ptr(ndr, "string1", r->string1);
9789         ndr->depth++;
9790         if (r->string1) {
9791                 ndr_print_string(ndr, "string1", r->string1);
9792         }
9793         ndr->depth--;
9794         ndr_print_ptr(ndr, "string2", r->string2);
9795         ndr->depth++;
9796         if (r->string2) {
9797                 ndr_print_string(ndr, "string2", r->string2);
9798         }
9799         ndr->depth--;
9800         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
9801         ndr->depth--;
9802 }
9803
9804 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfoRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaGetInfoRequest *r)
9805 {
9806         if (ndr_flags & NDR_SCALARS) {
9807                 int level = ndr_push_get_switch_value(ndr, r);
9808                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, level));
9809                 NDR_CHECK(ndr_push_union_align(ndr, 5));
9810                 switch (level) {
9811                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9812                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9813                         break; }
9814
9815                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9816                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9817                         break; }
9818
9819                         default:
9820                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9821                 }
9822         }
9823         if (ndr_flags & NDR_BUFFERS) {
9824                 int level = ndr_push_get_switch_value(ndr, r);
9825                 switch (level) {
9826                         case DRSUAPI_DS_REPLICA_GET_INFO:
9827                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9828                         break;
9829
9830                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9831                                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9832                         break;
9833
9834                         default:
9835                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9836                 }
9837         }
9838         return NDR_ERR_SUCCESS;
9839 }
9840
9841 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfoRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaGetInfoRequest *r)
9842 {
9843         int level;
9844         uint32_t _level;
9845         level = ndr_pull_get_switch_value(ndr, r);
9846         if (ndr_flags & NDR_SCALARS) {
9847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9848                 if (_level != level) {
9849                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
9850                 }
9851                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
9852                 switch (level) {
9853                         case DRSUAPI_DS_REPLICA_GET_INFO: {
9854                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_SCALARS, &r->req1));
9855                         break; }
9856
9857                         case DRSUAPI_DS_REPLICA_GET_INFO2: {
9858                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_SCALARS, &r->req2));
9859                         break; }
9860
9861                         default:
9862                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9863                 }
9864         }
9865         if (ndr_flags & NDR_BUFFERS) {
9866                 switch (level) {
9867                         case DRSUAPI_DS_REPLICA_GET_INFO:
9868                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest1(ndr, NDR_BUFFERS, &r->req1));
9869                         break;
9870
9871                         case DRSUAPI_DS_REPLICA_GET_INFO2:
9872                                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest2(ndr, NDR_BUFFERS, &r->req2));
9873                         break;
9874
9875                         default:
9876                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
9877                 }
9878         }
9879         return NDR_ERR_SUCCESS;
9880 }
9881
9882 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfoRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaGetInfoRequest *r)
9883 {
9884         int level;
9885         level = ndr_print_get_switch_value(ndr, r);
9886         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaGetInfoRequest");
9887         switch (level) {
9888                 case DRSUAPI_DS_REPLICA_GET_INFO:
9889                         ndr_print_drsuapi_DsReplicaGetInfoRequest1(ndr, "req1", &r->req1);
9890                 break;
9891
9892                 case DRSUAPI_DS_REPLICA_GET_INFO2:
9893                         ndr_print_drsuapi_DsReplicaGetInfoRequest2(ndr, "req2", &r->req2);
9894                 break;
9895
9896                 default:
9897                         ndr_print_bad_level(ndr, name, level);
9898         }
9899 }
9900
9901 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbour(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbour *r)
9902 {
9903         if (ndr_flags & NDR_SCALARS) {
9904                 NDR_CHECK(ndr_push_align(ndr, 8));
9905                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->naming_context_dn));
9906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
9907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address));
9908                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_obj_dn));
9909                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->replica_flags));
9910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
9911                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9912                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9913                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9914                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9915                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->tmp_highest_usn));
9916                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
9917                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_success));
9918                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_attempt));
9919                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->result_last_attempt));
9920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->consecutive_sync_failures));
9921                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
9922         }
9923         if (ndr_flags & NDR_BUFFERS) {
9924                 if (r->naming_context_dn) {
9925                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9926                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9927                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->naming_context_dn, CH_UTF16)));
9928                         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));
9929                 }
9930                 if (r->source_dsa_obj_dn) {
9931                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9932                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9933                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
9934                         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));
9935                 }
9936                 if (r->source_dsa_address) {
9937                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9938                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9939                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16)));
9940                         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));
9941                 }
9942                 if (r->transport_obj_dn) {
9943                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9944                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
9945                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->transport_obj_dn, CH_UTF16)));
9946                         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));
9947                 }
9948         }
9949         return NDR_ERR_SUCCESS;
9950 }
9951
9952 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbour(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbour *r)
9953 {
9954         uint32_t _ptr_naming_context_dn;
9955         TALLOC_CTX *_mem_save_naming_context_dn_0;
9956         uint32_t _ptr_source_dsa_obj_dn;
9957         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
9958         uint32_t _ptr_source_dsa_address;
9959         TALLOC_CTX *_mem_save_source_dsa_address_0;
9960         uint32_t _ptr_transport_obj_dn;
9961         TALLOC_CTX *_mem_save_transport_obj_dn_0;
9962         if (ndr_flags & NDR_SCALARS) {
9963                 NDR_CHECK(ndr_pull_align(ndr, 8));
9964                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_naming_context_dn));
9965                 if (_ptr_naming_context_dn) {
9966                         NDR_PULL_ALLOC(ndr, r->naming_context_dn);
9967                 } else {
9968                         r->naming_context_dn = NULL;
9969                 }
9970                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
9971                 if (_ptr_source_dsa_obj_dn) {
9972                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
9973                 } else {
9974                         r->source_dsa_obj_dn = NULL;
9975                 }
9976                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address));
9977                 if (_ptr_source_dsa_address) {
9978                         NDR_PULL_ALLOC(ndr, r->source_dsa_address);
9979                 } else {
9980                         r->source_dsa_address = NULL;
9981                 }
9982                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_obj_dn));
9983                 if (_ptr_transport_obj_dn) {
9984                         NDR_PULL_ALLOC(ndr, r->transport_obj_dn);
9985                 } else {
9986                         r->transport_obj_dn = NULL;
9987                 }
9988                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->replica_flags));
9989                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
9990                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->naming_context_obj_guid));
9991                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_obj_guid));
9992                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
9993                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->transport_obj_guid));
9994                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->tmp_highest_usn));
9995                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
9996                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_success));
9997                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_attempt));
9998                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->result_last_attempt));
9999                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->consecutive_sync_failures));
10000                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10001         }
10002         if (ndr_flags & NDR_BUFFERS) {
10003                 if (r->naming_context_dn) {
10004                         _mem_save_naming_context_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10005                         NDR_PULL_SET_MEM_CTX(ndr, r->naming_context_dn, 0);
10006                         NDR_CHECK(ndr_pull_array_size(ndr, &r->naming_context_dn));
10007                         NDR_CHECK(ndr_pull_array_length(ndr, &r->naming_context_dn));
10008                         if (ndr_get_array_length(ndr, &r->naming_context_dn) > ndr_get_array_size(ndr, &r->naming_context_dn)) {
10009                                 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));
10010                         }
10011                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->naming_context_dn), sizeof(uint16_t)));
10012                         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));
10013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_dn_0, 0);
10014                 }
10015                 if (r->source_dsa_obj_dn) {
10016                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10017                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
10018                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
10019                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
10020                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
10021                                 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));
10022                         }
10023                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
10024                         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));
10025                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
10026                 }
10027                 if (r->source_dsa_address) {
10028                         _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10029                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0);
10030                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address));
10031                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address));
10032                         if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) {
10033                                 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));
10034                         }
10035                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t)));
10036                         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));
10037                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0);
10038                 }
10039                 if (r->transport_obj_dn) {
10040                         _mem_save_transport_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10041                         NDR_PULL_SET_MEM_CTX(ndr, r->transport_obj_dn, 0);
10042                         NDR_CHECK(ndr_pull_array_size(ndr, &r->transport_obj_dn));
10043                         NDR_CHECK(ndr_pull_array_length(ndr, &r->transport_obj_dn));
10044                         if (ndr_get_array_length(ndr, &r->transport_obj_dn) > ndr_get_array_size(ndr, &r->transport_obj_dn)) {
10045                                 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));
10046                         }
10047                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->transport_obj_dn), sizeof(uint16_t)));
10048                         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));
10049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_obj_dn_0, 0);
10050                 }
10051         }
10052         return NDR_ERR_SUCCESS;
10053 }
10054
10055 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbour(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbour *r)
10056 {
10057         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbour");
10058         ndr->depth++;
10059         ndr_print_ptr(ndr, "naming_context_dn", r->naming_context_dn);
10060         ndr->depth++;
10061         if (r->naming_context_dn) {
10062                 ndr_print_string(ndr, "naming_context_dn", r->naming_context_dn);
10063         }
10064         ndr->depth--;
10065         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10066         ndr->depth++;
10067         if (r->source_dsa_obj_dn) {
10068                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
10069         }
10070         ndr->depth--;
10071         ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address);
10072         ndr->depth++;
10073         if (r->source_dsa_address) {
10074                 ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address);
10075         }
10076         ndr->depth--;
10077         ndr_print_ptr(ndr, "transport_obj_dn", r->transport_obj_dn);
10078         ndr->depth++;
10079         if (r->transport_obj_dn) {
10080                 ndr_print_string(ndr, "transport_obj_dn", r->transport_obj_dn);
10081         }
10082         ndr->depth--;
10083         ndr_print_drsuapi_DrsOptions(ndr, "replica_flags", r->replica_flags);
10084         ndr_print_uint32(ndr, "reserved", r->reserved);
10085         ndr_print_GUID(ndr, "naming_context_obj_guid", &r->naming_context_obj_guid);
10086         ndr_print_GUID(ndr, "source_dsa_obj_guid", &r->source_dsa_obj_guid);
10087         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
10088         ndr_print_GUID(ndr, "transport_obj_guid", &r->transport_obj_guid);
10089         ndr_print_hyper(ndr, "tmp_highest_usn", r->tmp_highest_usn);
10090         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
10091         ndr_print_NTTIME(ndr, "last_success", r->last_success);
10092         ndr_print_NTTIME(ndr, "last_attempt", r->last_attempt);
10093         ndr_print_WERROR(ndr, "result_last_attempt", r->result_last_attempt);
10094         ndr_print_uint32(ndr, "consecutive_sync_failures", r->consecutive_sync_failures);
10095         ndr->depth--;
10096 }
10097
10098 static enum ndr_err_code ndr_push_drsuapi_DsReplicaNeighbourCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaNeighbourCtr *r)
10099 {
10100         uint32_t cntr_array_0;
10101         if (ndr_flags & NDR_SCALARS) {
10102                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10103                 NDR_CHECK(ndr_push_align(ndr, 8));
10104                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10106                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10107                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10108                 }
10109                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10110         }
10111         if (ndr_flags & NDR_BUFFERS) {
10112                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10113                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10114                 }
10115         }
10116         return NDR_ERR_SUCCESS;
10117 }
10118
10119 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaNeighbourCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaNeighbourCtr *r)
10120 {
10121         uint32_t cntr_array_0;
10122         TALLOC_CTX *_mem_save_array_0;
10123         if (ndr_flags & NDR_SCALARS) {
10124                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10125                 NDR_CHECK(ndr_pull_align(ndr, 8));
10126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10128                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10129                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10130                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10131                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10132                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10133                 }
10134                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10135                 if (r->array) {
10136                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10137                 }
10138                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10139         }
10140         if (ndr_flags & NDR_BUFFERS) {
10141                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10142                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10143                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10144                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbour(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10145                 }
10146                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10147         }
10148         return NDR_ERR_SUCCESS;
10149 }
10150
10151 _PUBLIC_ void ndr_print_drsuapi_DsReplicaNeighbourCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaNeighbourCtr *r)
10152 {
10153         uint32_t cntr_array_0;
10154         ndr_print_struct(ndr, name, "drsuapi_DsReplicaNeighbourCtr");
10155         ndr->depth++;
10156         ndr_print_uint32(ndr, "count", r->count);
10157         ndr_print_uint32(ndr, "reserved", r->reserved);
10158         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10159         ndr->depth++;
10160         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10161                 char *idx_0=NULL;
10162                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10163                         ndr_print_drsuapi_DsReplicaNeighbour(ndr, "array", &r->array[cntr_array_0]);
10164                         free(idx_0);
10165                 }
10166         }
10167         ndr->depth--;
10168         ndr->depth--;
10169 }
10170
10171 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursorCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursorCtr *r)
10172 {
10173         uint32_t cntr_array_0;
10174         if (ndr_flags & NDR_SCALARS) {
10175                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10176                 NDR_CHECK(ndr_push_align(ndr, 8));
10177                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10179                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10180                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10181                 }
10182                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10183         }
10184         if (ndr_flags & NDR_BUFFERS) {
10185         }
10186         return NDR_ERR_SUCCESS;
10187 }
10188
10189 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursorCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursorCtr *r)
10190 {
10191         uint32_t cntr_array_0;
10192         TALLOC_CTX *_mem_save_array_0;
10193         if (ndr_flags & NDR_SCALARS) {
10194                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10195                 NDR_CHECK(ndr_pull_align(ndr, 8));
10196                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10197                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10198                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10199                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10200                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10201                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10202                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10203                 }
10204                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10205                 if (r->array) {
10206                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10207                 }
10208                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10209         }
10210         if (ndr_flags & NDR_BUFFERS) {
10211         }
10212         return NDR_ERR_SUCCESS;
10213 }
10214
10215 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursorCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursorCtr *r)
10216 {
10217         uint32_t cntr_array_0;
10218         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursorCtr");
10219         ndr->depth++;
10220         ndr_print_uint32(ndr, "count", r->count);
10221         ndr_print_uint32(ndr, "reserved", r->reserved);
10222         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10223         ndr->depth++;
10224         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10225                 char *idx_0=NULL;
10226                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10227                         ndr_print_drsuapi_DsReplicaCursor(ndr, "array", &r->array[cntr_array_0]);
10228                         free(idx_0);
10229                 }
10230         }
10231         ndr->depth--;
10232         ndr->depth--;
10233 }
10234
10235 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData *r)
10236 {
10237         if (ndr_flags & NDR_SCALARS) {
10238                 NDR_CHECK(ndr_push_align(ndr, 8));
10239                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10240                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10241                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10242                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10243                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10244                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10245                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10246         }
10247         if (ndr_flags & NDR_BUFFERS) {
10248                 if (r->attribute_name) {
10249                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10250                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10251                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10252                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10253                 }
10254         }
10255         return NDR_ERR_SUCCESS;
10256 }
10257
10258 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData *r)
10259 {
10260         uint32_t _ptr_attribute_name;
10261         TALLOC_CTX *_mem_save_attribute_name_0;
10262         if (ndr_flags & NDR_SCALARS) {
10263                 NDR_CHECK(ndr_pull_align(ndr, 8));
10264                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10265                 if (_ptr_attribute_name) {
10266                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10267                 } else {
10268                         r->attribute_name = NULL;
10269                 }
10270                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10271                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10272                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10273                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10274                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10275                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10276         }
10277         if (ndr_flags & NDR_BUFFERS) {
10278                 if (r->attribute_name) {
10279                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10280                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10281                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10282                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10283                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10284                                 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));
10285                         }
10286                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10287                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10289                 }
10290         }
10291         return NDR_ERR_SUCCESS;
10292 }
10293
10294 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData *r)
10295 {
10296         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData");
10297         ndr->depth++;
10298         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10299         ndr->depth++;
10300         if (r->attribute_name) {
10301                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10302         }
10303         ndr->depth--;
10304         ndr_print_uint32(ndr, "version", r->version);
10305         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10306         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10307         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10308         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10309         ndr->depth--;
10310 }
10311
10312 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10313 {
10314         uint32_t cntr_array_0;
10315         if (ndr_flags & NDR_SCALARS) {
10316                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10317                 NDR_CHECK(ndr_push_align(ndr, 8));
10318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10320                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10321                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10322                 }
10323                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10324         }
10325         if (ndr_flags & NDR_BUFFERS) {
10326                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10327                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10328                 }
10329         }
10330         return NDR_ERR_SUCCESS;
10331 }
10332
10333 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaDataCtr *r)
10334 {
10335         uint32_t cntr_array_0;
10336         TALLOC_CTX *_mem_save_array_0;
10337         if (ndr_flags & NDR_SCALARS) {
10338                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10339                 NDR_CHECK(ndr_pull_align(ndr, 8));
10340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10342                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10343                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10344                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10345                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10346                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10347                 }
10348                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10349                 if (r->array) {
10350                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10351                 }
10352                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10353         }
10354         if (ndr_flags & NDR_BUFFERS) {
10355                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10356                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10357                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10358                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10359                 }
10360                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10361         }
10362         return NDR_ERR_SUCCESS;
10363 }
10364
10365 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaDataCtr *r)
10366 {
10367         uint32_t cntr_array_0;
10368         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaDataCtr");
10369         ndr->depth++;
10370         ndr_print_uint32(ndr, "count", r->count);
10371         ndr_print_uint32(ndr, "reserved", r->reserved);
10372         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10373         ndr->depth++;
10374         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10375                 char *idx_0=NULL;
10376                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10377                         ndr_print_drsuapi_DsReplicaObjMetaData(ndr, "array", &r->array[cntr_array_0]);
10378                         free(idx_0);
10379                 }
10380         }
10381         ndr->depth--;
10382         ndr->depth--;
10383 }
10384
10385 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailure(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailure *r)
10386 {
10387         if (ndr_flags & NDR_SCALARS) {
10388                 NDR_CHECK(ndr_push_align(ndr, 5));
10389                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dsa_obj_dn));
10390                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10391                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->first_failure));
10392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_failures));
10393                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_result));
10394                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10395         }
10396         if (ndr_flags & NDR_BUFFERS) {
10397                 if (r->dsa_obj_dn) {
10398                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10399                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10400                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->dsa_obj_dn, CH_UTF16)));
10401                         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));
10402                 }
10403         }
10404         return NDR_ERR_SUCCESS;
10405 }
10406
10407 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailure(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailure *r)
10408 {
10409         uint32_t _ptr_dsa_obj_dn;
10410         TALLOC_CTX *_mem_save_dsa_obj_dn_0;
10411         if (ndr_flags & NDR_SCALARS) {
10412                 NDR_CHECK(ndr_pull_align(ndr, 5));
10413                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dsa_obj_dn));
10414                 if (_ptr_dsa_obj_dn) {
10415                         NDR_PULL_ALLOC(ndr, r->dsa_obj_dn);
10416                 } else {
10417                         r->dsa_obj_dn = NULL;
10418                 }
10419                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->dsa_obj_guid));
10420                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->first_failure));
10421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_failures));
10422                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_result));
10423                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10424         }
10425         if (ndr_flags & NDR_BUFFERS) {
10426                 if (r->dsa_obj_dn) {
10427                         _mem_save_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10428                         NDR_PULL_SET_MEM_CTX(ndr, r->dsa_obj_dn, 0);
10429                         NDR_CHECK(ndr_pull_array_size(ndr, &r->dsa_obj_dn));
10430                         NDR_CHECK(ndr_pull_array_length(ndr, &r->dsa_obj_dn));
10431                         if (ndr_get_array_length(ndr, &r->dsa_obj_dn) > ndr_get_array_size(ndr, &r->dsa_obj_dn)) {
10432                                 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));
10433                         }
10434                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->dsa_obj_dn), sizeof(uint16_t)));
10435                         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));
10436                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dsa_obj_dn_0, 0);
10437                 }
10438         }
10439         return NDR_ERR_SUCCESS;
10440 }
10441
10442 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailure(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailure *r)
10443 {
10444         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailure");
10445         ndr->depth++;
10446         ndr_print_ptr(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10447         ndr->depth++;
10448         if (r->dsa_obj_dn) {
10449                 ndr_print_string(ndr, "dsa_obj_dn", r->dsa_obj_dn);
10450         }
10451         ndr->depth--;
10452         ndr_print_GUID(ndr, "dsa_obj_guid", &r->dsa_obj_guid);
10453         ndr_print_NTTIME(ndr, "first_failure", r->first_failure);
10454         ndr_print_uint32(ndr, "num_failures", r->num_failures);
10455         ndr_print_WERROR(ndr, "last_result", r->last_result);
10456         ndr->depth--;
10457 }
10458
10459 static enum ndr_err_code ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10460 {
10461         uint32_t cntr_array_0;
10462         if (ndr_flags & NDR_SCALARS) {
10463                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10464                 NDR_CHECK(ndr_push_align(ndr, 5));
10465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10466                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
10467                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10468                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10469                 }
10470                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10471         }
10472         if (ndr_flags & NDR_BUFFERS) {
10473                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10474                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10475                 }
10476         }
10477         return NDR_ERR_SUCCESS;
10478 }
10479
10480 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10481 {
10482         uint32_t cntr_array_0;
10483         TALLOC_CTX *_mem_save_array_0;
10484         if (ndr_flags & NDR_SCALARS) {
10485                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10486                 NDR_CHECK(ndr_pull_align(ndr, 5));
10487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10488                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
10489                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10490                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10491                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10492                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10493                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10494                 }
10495                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10496                 if (r->array) {
10497                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10498                 }
10499                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10500         }
10501         if (ndr_flags & NDR_BUFFERS) {
10502                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10503                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10504                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10505                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailure(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10506                 }
10507                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10508         }
10509         return NDR_ERR_SUCCESS;
10510 }
10511
10512 _PUBLIC_ void ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaKccDsaFailuresCtr *r)
10513 {
10514         uint32_t cntr_array_0;
10515         ndr_print_struct(ndr, name, "drsuapi_DsReplicaKccDsaFailuresCtr");
10516         ndr->depth++;
10517         ndr_print_uint32(ndr, "count", r->count);
10518         ndr_print_uint32(ndr, "reserved", r->reserved);
10519         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10520         ndr->depth++;
10521         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10522                 char *idx_0=NULL;
10523                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10524                         ndr_print_drsuapi_DsReplicaKccDsaFailure(ndr, "array", &r->array[cntr_array_0]);
10525                         free(idx_0);
10526                 }
10527         }
10528         ndr->depth--;
10529         ndr->depth--;
10530 }
10531
10532 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType r)
10533 {
10534         NDR_CHECK(ndr_push_enum_uint1632(ndr, NDR_SCALARS, r));
10535         return NDR_ERR_SUCCESS;
10536 }
10537
10538 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpType(struct ndr_pull *ndr, int ndr_flags, enum drsuapi_DsReplicaOpType *r)
10539 {
10540         uint16_t v;
10541         NDR_CHECK(ndr_pull_enum_uint1632(ndr, NDR_SCALARS, &v));
10542         *r = v;
10543         return NDR_ERR_SUCCESS;
10544 }
10545
10546 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpType(struct ndr_print *ndr, const char *name, enum drsuapi_DsReplicaOpType r)
10547 {
10548         const char *val = NULL;
10549
10550         switch (r) {
10551                 case DRSUAPI_DS_REPLICA_OP_TYPE_SYNC: val = "DRSUAPI_DS_REPLICA_OP_TYPE_SYNC"; break;
10552                 case DRSUAPI_DS_REPLICA_OP_TYPE_ADD: val = "DRSUAPI_DS_REPLICA_OP_TYPE_ADD"; break;
10553                 case DRSUAPI_DS_REPLICA_OP_TYPE_DELETE: val = "DRSUAPI_DS_REPLICA_OP_TYPE_DELETE"; break;
10554                 case DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY: val = "DRSUAPI_DS_REPLICA_OP_TYPE_MODIFY"; break;
10555                 case DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS: val = "DRSUAPI_DS_REPLICA_OP_TYPE_UPDATE_REFS"; break;
10556         }
10557         ndr_print_enum(ndr, name, "ENUM", val, r);
10558 }
10559
10560 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOp(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOp *r)
10561 {
10562         if (ndr_flags & NDR_SCALARS) {
10563                 NDR_CHECK(ndr_push_align(ndr, 5));
10564                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->operation_start));
10565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->serial_num));
10566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
10567                 NDR_CHECK(ndr_push_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, r->operation_type));
10568                 NDR_CHECK(ndr_push_drsuapi_DrsOptions(ndr, NDR_SCALARS, r->options));
10569                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->nc_dn));
10570                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_obj_dn));
10571                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->remote_dsa_address));
10572                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10573                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10574                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10575         }
10576         if (ndr_flags & NDR_BUFFERS) {
10577                 if (r->nc_dn) {
10578                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10579                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10580                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->nc_dn, CH_UTF16)));
10581                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->nc_dn, ndr_charset_length(r->nc_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10582                 }
10583                 if (r->remote_dsa_obj_dn) {
10584                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10585                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10586                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_obj_dn, CH_UTF16)));
10587                         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));
10588                 }
10589                 if (r->remote_dsa_address) {
10590                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10591                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10592                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->remote_dsa_address, CH_UTF16)));
10593                         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));
10594                 }
10595         }
10596         return NDR_ERR_SUCCESS;
10597 }
10598
10599 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOp(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOp *r)
10600 {
10601         uint32_t _ptr_nc_dn;
10602         TALLOC_CTX *_mem_save_nc_dn_0;
10603         uint32_t _ptr_remote_dsa_obj_dn;
10604         TALLOC_CTX *_mem_save_remote_dsa_obj_dn_0;
10605         uint32_t _ptr_remote_dsa_address;
10606         TALLOC_CTX *_mem_save_remote_dsa_address_0;
10607         if (ndr_flags & NDR_SCALARS) {
10608                 NDR_CHECK(ndr_pull_align(ndr, 5));
10609                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->operation_start));
10610                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->serial_num));
10611                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
10612                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpType(ndr, NDR_SCALARS, &r->operation_type));
10613                 NDR_CHECK(ndr_pull_drsuapi_DrsOptions(ndr, NDR_SCALARS, &r->options));
10614                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_nc_dn));
10615                 if (_ptr_nc_dn) {
10616                         NDR_PULL_ALLOC(ndr, r->nc_dn);
10617                 } else {
10618                         r->nc_dn = NULL;
10619                 }
10620                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_obj_dn));
10621                 if (_ptr_remote_dsa_obj_dn) {
10622                         NDR_PULL_ALLOC(ndr, r->remote_dsa_obj_dn);
10623                 } else {
10624                         r->remote_dsa_obj_dn = NULL;
10625                 }
10626                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_remote_dsa_address));
10627                 if (_ptr_remote_dsa_address) {
10628                         NDR_PULL_ALLOC(ndr, r->remote_dsa_address);
10629                 } else {
10630                         r->remote_dsa_address = NULL;
10631                 }
10632                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->nc_obj_guid));
10633                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->remote_dsa_obj_guid));
10634                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10635         }
10636         if (ndr_flags & NDR_BUFFERS) {
10637                 if (r->nc_dn) {
10638                         _mem_save_nc_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10639                         NDR_PULL_SET_MEM_CTX(ndr, r->nc_dn, 0);
10640                         NDR_CHECK(ndr_pull_array_size(ndr, &r->nc_dn));
10641                         NDR_CHECK(ndr_pull_array_length(ndr, &r->nc_dn));
10642                         if (ndr_get_array_length(ndr, &r->nc_dn) > ndr_get_array_size(ndr, &r->nc_dn)) {
10643                                 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));
10644                         }
10645                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t)));
10646                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->nc_dn, ndr_get_array_length(ndr, &r->nc_dn), sizeof(uint16_t), CH_UTF16));
10647                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_nc_dn_0, 0);
10648                 }
10649                 if (r->remote_dsa_obj_dn) {
10650                         _mem_save_remote_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10651                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_obj_dn, 0);
10652                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_obj_dn));
10653                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_obj_dn));
10654                         if (ndr_get_array_length(ndr, &r->remote_dsa_obj_dn) > ndr_get_array_size(ndr, &r->remote_dsa_obj_dn)) {
10655                                 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));
10656                         }
10657                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_obj_dn), sizeof(uint16_t)));
10658                         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));
10659                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_obj_dn_0, 0);
10660                 }
10661                 if (r->remote_dsa_address) {
10662                         _mem_save_remote_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr);
10663                         NDR_PULL_SET_MEM_CTX(ndr, r->remote_dsa_address, 0);
10664                         NDR_CHECK(ndr_pull_array_size(ndr, &r->remote_dsa_address));
10665                         NDR_CHECK(ndr_pull_array_length(ndr, &r->remote_dsa_address));
10666                         if (ndr_get_array_length(ndr, &r->remote_dsa_address) > ndr_get_array_size(ndr, &r->remote_dsa_address)) {
10667                                 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));
10668                         }
10669                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->remote_dsa_address), sizeof(uint16_t)));
10670                         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));
10671                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_remote_dsa_address_0, 0);
10672                 }
10673         }
10674         return NDR_ERR_SUCCESS;
10675 }
10676
10677 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOp(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOp *r)
10678 {
10679         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOp");
10680         ndr->depth++;
10681         ndr_print_NTTIME(ndr, "operation_start", r->operation_start);
10682         ndr_print_uint32(ndr, "serial_num", r->serial_num);
10683         ndr_print_uint32(ndr, "priority", r->priority);
10684         ndr_print_drsuapi_DsReplicaOpType(ndr, "operation_type", r->operation_type);
10685         ndr_print_drsuapi_DrsOptions(ndr, "options", r->options);
10686         ndr_print_ptr(ndr, "nc_dn", r->nc_dn);
10687         ndr->depth++;
10688         if (r->nc_dn) {
10689                 ndr_print_string(ndr, "nc_dn", r->nc_dn);
10690         }
10691         ndr->depth--;
10692         ndr_print_ptr(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10693         ndr->depth++;
10694         if (r->remote_dsa_obj_dn) {
10695                 ndr_print_string(ndr, "remote_dsa_obj_dn", r->remote_dsa_obj_dn);
10696         }
10697         ndr->depth--;
10698         ndr_print_ptr(ndr, "remote_dsa_address", r->remote_dsa_address);
10699         ndr->depth++;
10700         if (r->remote_dsa_address) {
10701                 ndr_print_string(ndr, "remote_dsa_address", r->remote_dsa_address);
10702         }
10703         ndr->depth--;
10704         ndr_print_GUID(ndr, "nc_obj_guid", &r->nc_obj_guid);
10705         ndr_print_GUID(ndr, "remote_dsa_obj_guid", &r->remote_dsa_obj_guid);
10706         ndr->depth--;
10707 }
10708
10709 static enum ndr_err_code ndr_push_drsuapi_DsReplicaOpCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOpCtr *r)
10710 {
10711         uint32_t cntr_array_0;
10712         if (ndr_flags & NDR_SCALARS) {
10713                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10714                 NDR_CHECK(ndr_push_align(ndr, 5));
10715                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->time));
10716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10717                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10718                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10719                 }
10720                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
10721         }
10722         if (ndr_flags & NDR_BUFFERS) {
10723                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10724                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10725                 }
10726         }
10727         return NDR_ERR_SUCCESS;
10728 }
10729
10730 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaOpCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOpCtr *r)
10731 {
10732         uint32_t cntr_array_0;
10733         TALLOC_CTX *_mem_save_array_0;
10734         if (ndr_flags & NDR_SCALARS) {
10735                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10736                 NDR_CHECK(ndr_pull_align(ndr, 5));
10737                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->time));
10738                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10739                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10740                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10741                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10742                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10743                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10744                 }
10745                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10746                 if (r->array) {
10747                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10748                 }
10749                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
10750         }
10751         if (ndr_flags & NDR_BUFFERS) {
10752                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10753                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10754                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10755                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOp(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10756                 }
10757                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10758         }
10759         return NDR_ERR_SUCCESS;
10760 }
10761
10762 _PUBLIC_ void ndr_print_drsuapi_DsReplicaOpCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOpCtr *r)
10763 {
10764         uint32_t cntr_array_0;
10765         ndr_print_struct(ndr, name, "drsuapi_DsReplicaOpCtr");
10766         ndr->depth++;
10767         ndr_print_NTTIME(ndr, "time", r->time);
10768         ndr_print_uint32(ndr, "count", r->count);
10769         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10770         ndr->depth++;
10771         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10772                 char *idx_0=NULL;
10773                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10774                         ndr_print_drsuapi_DsReplicaOp(ndr, "array", &r->array[cntr_array_0]);
10775                         free(idx_0);
10776                 }
10777         }
10778         ndr->depth--;
10779         ndr->depth--;
10780 }
10781
10782 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData *r)
10783 {
10784         if (ndr_flags & NDR_SCALARS) {
10785                 NDR_CHECK(ndr_push_align(ndr, 8));
10786                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
10787                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
10788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
10789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
10790                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
10791                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
10792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
10793                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
10794                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10795                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
10796                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
10797                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10798         }
10799         if (ndr_flags & NDR_BUFFERS) {
10800                 if (r->attribute_name) {
10801                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10802                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10803                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
10804                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10805                 }
10806                 if (r->object_dn) {
10807                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10808                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
10809                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
10810                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10811                 }
10812                 if (r->binary) {
10813                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
10814                 }
10815         }
10816         return NDR_ERR_SUCCESS;
10817 }
10818
10819 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData *r)
10820 {
10821         uint32_t _ptr_attribute_name;
10822         TALLOC_CTX *_mem_save_attribute_name_0;
10823         uint32_t _ptr_object_dn;
10824         TALLOC_CTX *_mem_save_object_dn_0;
10825         uint32_t _ptr_binary;
10826         TALLOC_CTX *_mem_save_binary_0;
10827         if (ndr_flags & NDR_SCALARS) {
10828                 NDR_CHECK(ndr_pull_align(ndr, 8));
10829                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
10830                 if (_ptr_attribute_name) {
10831                         NDR_PULL_ALLOC(ndr, r->attribute_name);
10832                 } else {
10833                         r->attribute_name = NULL;
10834                 }
10835                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
10836                 if (_ptr_object_dn) {
10837                         NDR_PULL_ALLOC(ndr, r->object_dn);
10838                 } else {
10839                         r->object_dn = NULL;
10840                 }
10841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
10842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
10843                 if (_ptr_binary) {
10844                         NDR_PULL_ALLOC(ndr, r->binary);
10845                 } else {
10846                         r->binary = NULL;
10847                 }
10848                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
10849                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
10850                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
10851                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
10852                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
10853                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
10854                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
10855                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10856         }
10857         if (ndr_flags & NDR_BUFFERS) {
10858                 if (r->attribute_name) {
10859                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10860                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
10861                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
10862                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
10863                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
10864                                 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));
10865                         }
10866                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
10867                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
10868                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
10869                 }
10870                 if (r->object_dn) {
10871                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
10872                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
10873                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
10874                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
10875                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
10876                                 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));
10877                         }
10878                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
10879                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
10880                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
10881                 }
10882                 if (r->binary) {
10883                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
10884                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
10885                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
10886                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
10887                 }
10888         }
10889         return NDR_ERR_SUCCESS;
10890 }
10891
10892 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData *r)
10893 {
10894         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData");
10895         ndr->depth++;
10896         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
10897         ndr->depth++;
10898         if (r->attribute_name) {
10899                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
10900         }
10901         ndr->depth--;
10902         ndr_print_ptr(ndr, "object_dn", r->object_dn);
10903         ndr->depth++;
10904         if (r->object_dn) {
10905                 ndr_print_string(ndr, "object_dn", r->object_dn);
10906         }
10907         ndr->depth--;
10908         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);
10909         ndr_print_ptr(ndr, "binary", r->binary);
10910         ndr->depth++;
10911         if (r->binary) {
10912                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
10913         }
10914         ndr->depth--;
10915         ndr_print_NTTIME(ndr, "deleted", r->deleted);
10916         ndr_print_NTTIME(ndr, "created", r->created);
10917         ndr_print_uint32(ndr, "version", r->version);
10918         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
10919         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
10920         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
10921         ndr_print_hyper(ndr, "local_usn", r->local_usn);
10922         ndr->depth--;
10923 }
10924
10925 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10926 {
10927         uint32_t cntr_array_0;
10928         if (ndr_flags & NDR_SCALARS) {
10929                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
10930                 NDR_CHECK(ndr_push_align(ndr, 8));
10931                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
10932                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
10933                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10934                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10935                 }
10936                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
10937         }
10938         if (ndr_flags & NDR_BUFFERS) {
10939                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10940                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10941                 }
10942         }
10943         return NDR_ERR_SUCCESS;
10944 }
10945
10946 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10947 {
10948         uint32_t cntr_array_0;
10949         TALLOC_CTX *_mem_save_array_0;
10950         if (ndr_flags & NDR_SCALARS) {
10951                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
10952                 NDR_CHECK(ndr_pull_align(ndr, 8));
10953                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
10954                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
10955                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
10956                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10957                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10958                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10959                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
10960                 }
10961                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10962                 if (r->array) {
10963                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
10964                 }
10965                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
10966         }
10967         if (ndr_flags & NDR_BUFFERS) {
10968                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
10969                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
10970                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
10971                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
10972                 }
10973                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
10974         }
10975         return NDR_ERR_SUCCESS;
10976 }
10977
10978 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaDataCtr *r)
10979 {
10980         uint32_t cntr_array_0;
10981         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaDataCtr");
10982         ndr->depth++;
10983         ndr_print_uint32(ndr, "count", r->count);
10984         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
10985         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
10986         ndr->depth++;
10987         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
10988                 char *idx_0=NULL;
10989                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
10990                         ndr_print_drsuapi_DsReplicaAttrValMetaData(ndr, "array", &r->array[cntr_array_0]);
10991                         free(idx_0);
10992                 }
10993         }
10994         ndr->depth--;
10995         ndr->depth--;
10996 }
10997
10998 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor2Ctr *r)
10999 {
11000         uint32_t cntr_array_0;
11001         if (ndr_flags & NDR_SCALARS) {
11002                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11003                 NDR_CHECK(ndr_push_align(ndr, 8));
11004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11005                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11006                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11007                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11008                 }
11009                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11010         }
11011         if (ndr_flags & NDR_BUFFERS) {
11012         }
11013         return NDR_ERR_SUCCESS;
11014 }
11015
11016 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor2Ctr *r)
11017 {
11018         uint32_t cntr_array_0;
11019         TALLOC_CTX *_mem_save_array_0;
11020         if (ndr_flags & NDR_SCALARS) {
11021                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11022                 NDR_CHECK(ndr_pull_align(ndr, 8));
11023                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11024                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11025                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11026                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11027                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11028                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11029                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11030                 }
11031                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11032                 if (r->array) {
11033                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11034                 }
11035                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11036         }
11037         if (ndr_flags & NDR_BUFFERS) {
11038         }
11039         return NDR_ERR_SUCCESS;
11040 }
11041
11042 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor2Ctr *r)
11043 {
11044         uint32_t cntr_array_0;
11045         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor2Ctr");
11046         ndr->depth++;
11047         ndr_print_uint32(ndr, "count", r->count);
11048         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11049         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11050         ndr->depth++;
11051         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11052                 char *idx_0=NULL;
11053                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11054                         ndr_print_drsuapi_DsReplicaCursor2(ndr, "array", &r->array[cntr_array_0]);
11055                         free(idx_0);
11056                 }
11057         }
11058         ndr->depth--;
11059         ndr->depth--;
11060 }
11061
11062 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3 *r)
11063 {
11064         if (ndr_flags & NDR_SCALARS) {
11065                 NDR_CHECK(ndr_push_align(ndr, 8));
11066                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11067                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->highest_usn));
11068                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->last_sync_success));
11069                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_obj_dn));
11070                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11071         }
11072         if (ndr_flags & NDR_BUFFERS) {
11073                 if (r->source_dsa_obj_dn) {
11074                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11075                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11076                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_obj_dn, CH_UTF16)));
11077                         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));
11078                 }
11079         }
11080         return NDR_ERR_SUCCESS;
11081 }
11082
11083 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3 *r)
11084 {
11085         uint32_t _ptr_source_dsa_obj_dn;
11086         TALLOC_CTX *_mem_save_source_dsa_obj_dn_0;
11087         if (ndr_flags & NDR_SCALARS) {
11088                 NDR_CHECK(ndr_pull_align(ndr, 8));
11089                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dsa_invocation_id));
11090                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->highest_usn));
11091                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->last_sync_success));
11092                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_obj_dn));
11093                 if (_ptr_source_dsa_obj_dn) {
11094                         NDR_PULL_ALLOC(ndr, r->source_dsa_obj_dn);
11095                 } else {
11096                         r->source_dsa_obj_dn = NULL;
11097                 }
11098                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11099         }
11100         if (ndr_flags & NDR_BUFFERS) {
11101                 if (r->source_dsa_obj_dn) {
11102                         _mem_save_source_dsa_obj_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11103                         NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_obj_dn, 0);
11104                         NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_obj_dn));
11105                         NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_obj_dn));
11106                         if (ndr_get_array_length(ndr, &r->source_dsa_obj_dn) > ndr_get_array_size(ndr, &r->source_dsa_obj_dn)) {
11107                                 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));
11108                         }
11109                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_obj_dn), sizeof(uint16_t)));
11110                         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));
11111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_obj_dn_0, 0);
11112                 }
11113         }
11114         return NDR_ERR_SUCCESS;
11115 }
11116
11117 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3 *r)
11118 {
11119         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3");
11120         ndr->depth++;
11121         ndr_print_GUID(ndr, "source_dsa_invocation_id", &r->source_dsa_invocation_id);
11122         ndr_print_hyper(ndr, "highest_usn", r->highest_usn);
11123         ndr_print_NTTIME(ndr, "last_sync_success", r->last_sync_success);
11124         ndr_print_ptr(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11125         ndr->depth++;
11126         if (r->source_dsa_obj_dn) {
11127                 ndr_print_string(ndr, "source_dsa_obj_dn", r->source_dsa_obj_dn);
11128         }
11129         ndr->depth--;
11130         ndr->depth--;
11131 }
11132
11133 static enum ndr_err_code ndr_push_drsuapi_DsReplicaCursor3Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaCursor3Ctr *r)
11134 {
11135         uint32_t cntr_array_0;
11136         if (ndr_flags & NDR_SCALARS) {
11137                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11138                 NDR_CHECK(ndr_push_align(ndr, 8));
11139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11140                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11141                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11142                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11143                 }
11144                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11145         }
11146         if (ndr_flags & NDR_BUFFERS) {
11147                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11148                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11149                 }
11150         }
11151         return NDR_ERR_SUCCESS;
11152 }
11153
11154 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaCursor3Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaCursor3Ctr *r)
11155 {
11156         uint32_t cntr_array_0;
11157         TALLOC_CTX *_mem_save_array_0;
11158         if (ndr_flags & NDR_SCALARS) {
11159                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11160                 NDR_CHECK(ndr_pull_align(ndr, 8));
11161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11163                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11164                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11165                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11166                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11167                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11168                 }
11169                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11170                 if (r->array) {
11171                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11172                 }
11173                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11174         }
11175         if (ndr_flags & NDR_BUFFERS) {
11176                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11177                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11178                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11179                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11180                 }
11181                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11182         }
11183         return NDR_ERR_SUCCESS;
11184 }
11185
11186 _PUBLIC_ void ndr_print_drsuapi_DsReplicaCursor3Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaCursor3Ctr *r)
11187 {
11188         uint32_t cntr_array_0;
11189         ndr_print_struct(ndr, name, "drsuapi_DsReplicaCursor3Ctr");
11190         ndr->depth++;
11191         ndr_print_uint32(ndr, "count", r->count);
11192         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11193         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11194         ndr->depth++;
11195         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11196                 char *idx_0=NULL;
11197                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11198                         ndr_print_drsuapi_DsReplicaCursor3(ndr, "array", &r->array[cntr_array_0]);
11199                         free(idx_0);
11200                 }
11201         }
11202         ndr->depth--;
11203         ndr->depth--;
11204 }
11205
11206 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2 *r)
11207 {
11208         if (ndr_flags & NDR_SCALARS) {
11209                 NDR_CHECK(ndr_push_align(ndr, 8));
11210                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11211                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11212                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11213                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11214                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11215                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11216                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11217                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11218         }
11219         if (ndr_flags & NDR_BUFFERS) {
11220                 if (r->attribute_name) {
11221                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11222                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11223                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11224                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11225                 }
11226                 if (r->originating_dsa_dn) {
11227                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11228                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11229                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11230                         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));
11231                 }
11232         }
11233         return NDR_ERR_SUCCESS;
11234 }
11235
11236 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2 *r)
11237 {
11238         uint32_t _ptr_attribute_name;
11239         TALLOC_CTX *_mem_save_attribute_name_0;
11240         uint32_t _ptr_originating_dsa_dn;
11241         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11242         if (ndr_flags & NDR_SCALARS) {
11243                 NDR_CHECK(ndr_pull_align(ndr, 8));
11244                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11245                 if (_ptr_attribute_name) {
11246                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11247                 } else {
11248                         r->attribute_name = NULL;
11249                 }
11250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11251                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11252                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11253                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11254                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11255                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11256                 if (_ptr_originating_dsa_dn) {
11257                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11258                 } else {
11259                         r->originating_dsa_dn = NULL;
11260                 }
11261                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11262         }
11263         if (ndr_flags & NDR_BUFFERS) {
11264                 if (r->attribute_name) {
11265                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11266                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11267                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11268                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11269                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11270                                 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));
11271                         }
11272                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11273                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11274                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11275                 }
11276                 if (r->originating_dsa_dn) {
11277                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11278                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11279                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11280                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11281                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11282                                 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));
11283                         }
11284                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11285                         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));
11286                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11287                 }
11288         }
11289         return NDR_ERR_SUCCESS;
11290 }
11291
11292 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2 *r)
11293 {
11294         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2");
11295         ndr->depth++;
11296         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11297         ndr->depth++;
11298         if (r->attribute_name) {
11299                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11300         }
11301         ndr->depth--;
11302         ndr_print_uint32(ndr, "version", r->version);
11303         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11304         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11305         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11306         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11307         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11308         ndr->depth++;
11309         if (r->originating_dsa_dn) {
11310                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11311         }
11312         ndr->depth--;
11313         ndr->depth--;
11314 }
11315
11316 static enum ndr_err_code ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11317 {
11318         uint32_t cntr_array_0;
11319         if (ndr_flags & NDR_SCALARS) {
11320                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11321                 NDR_CHECK(ndr_push_align(ndr, 8));
11322                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11324                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11325                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11326                 }
11327                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11328         }
11329         if (ndr_flags & NDR_BUFFERS) {
11330                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11331                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11332                 }
11333         }
11334         return NDR_ERR_SUCCESS;
11335 }
11336
11337 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11338 {
11339         uint32_t cntr_array_0;
11340         TALLOC_CTX *_mem_save_array_0;
11341         if (ndr_flags & NDR_SCALARS) {
11342                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11343                 NDR_CHECK(ndr_pull_align(ndr, 8));
11344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11346                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11347                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11348                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11349                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11350                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11351                 }
11352                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11353                 if (r->array) {
11354                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11355                 }
11356                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11357         }
11358         if (ndr_flags & NDR_BUFFERS) {
11359                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11360                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11361                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11362                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11363                 }
11364                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11365         }
11366         return NDR_ERR_SUCCESS;
11367 }
11368
11369 _PUBLIC_ void ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaObjMetaData2Ctr *r)
11370 {
11371         uint32_t cntr_array_0;
11372         ndr_print_struct(ndr, name, "drsuapi_DsReplicaObjMetaData2Ctr");
11373         ndr->depth++;
11374         ndr_print_uint32(ndr, "count", r->count);
11375         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11376         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11377         ndr->depth++;
11378         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11379                 char *idx_0=NULL;
11380                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11381                         ndr_print_drsuapi_DsReplicaObjMetaData2(ndr, "array", &r->array[cntr_array_0]);
11382                         free(idx_0);
11383                 }
11384         }
11385         ndr->depth--;
11386         ndr->depth--;
11387 }
11388
11389 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11390 {
11391         if (ndr_flags & NDR_SCALARS) {
11392                 NDR_CHECK(ndr_push_align(ndr, 8));
11393                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attribute_name));
11394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->object_dn));
11395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_DATA_BLOB(0, r->binary, 0)));
11396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->binary));
11397                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->deleted));
11398                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->created));
11399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
11400                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->originating_change_time));
11401                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11402                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->originating_usn));
11403                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->local_usn));
11404                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->originating_dsa_dn));
11405                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11406         }
11407         if (ndr_flags & NDR_BUFFERS) {
11408                 if (r->attribute_name) {
11409                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11410                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11411                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->attribute_name, CH_UTF16)));
11412                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->attribute_name, ndr_charset_length(r->attribute_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11413                 }
11414                 if (r->object_dn) {
11415                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11416                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11417                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->object_dn, CH_UTF16)));
11418                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->object_dn, ndr_charset_length(r->object_dn, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11419                 }
11420                 if (r->binary) {
11421                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->binary));
11422                 }
11423                 if (r->originating_dsa_dn) {
11424                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11425                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11426                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->originating_dsa_dn, CH_UTF16)));
11427                         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));
11428                 }
11429         }
11430         return NDR_ERR_SUCCESS;
11431 }
11432
11433 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2 *r)
11434 {
11435         uint32_t _ptr_attribute_name;
11436         TALLOC_CTX *_mem_save_attribute_name_0;
11437         uint32_t _ptr_object_dn;
11438         TALLOC_CTX *_mem_save_object_dn_0;
11439         uint32_t _ptr_binary;
11440         TALLOC_CTX *_mem_save_binary_0;
11441         uint32_t _ptr_originating_dsa_dn;
11442         TALLOC_CTX *_mem_save_originating_dsa_dn_0;
11443         if (ndr_flags & NDR_SCALARS) {
11444                 NDR_CHECK(ndr_pull_align(ndr, 8));
11445                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attribute_name));
11446                 if (_ptr_attribute_name) {
11447                         NDR_PULL_ALLOC(ndr, r->attribute_name);
11448                 } else {
11449                         r->attribute_name = NULL;
11450                 }
11451                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_object_dn));
11452                 if (_ptr_object_dn) {
11453                         NDR_PULL_ALLOC(ndr, r->object_dn);
11454                 } else {
11455                         r->object_dn = NULL;
11456                 }
11457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size_binary));
11458                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_binary));
11459                 if (_ptr_binary) {
11460                         NDR_PULL_ALLOC(ndr, r->binary);
11461                 } else {
11462                         r->binary = NULL;
11463                 }
11464                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->deleted));
11465                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->created));
11466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
11467                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->originating_change_time));
11468                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->originating_invocation_id));
11469                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->originating_usn));
11470                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->local_usn));
11471                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_originating_dsa_dn));
11472                 if (_ptr_originating_dsa_dn) {
11473                         NDR_PULL_ALLOC(ndr, r->originating_dsa_dn);
11474                 } else {
11475                         r->originating_dsa_dn = NULL;
11476                 }
11477                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11478         }
11479         if (ndr_flags & NDR_BUFFERS) {
11480                 if (r->attribute_name) {
11481                         _mem_save_attribute_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11482                         NDR_PULL_SET_MEM_CTX(ndr, r->attribute_name, 0);
11483                         NDR_CHECK(ndr_pull_array_size(ndr, &r->attribute_name));
11484                         NDR_CHECK(ndr_pull_array_length(ndr, &r->attribute_name));
11485                         if (ndr_get_array_length(ndr, &r->attribute_name) > ndr_get_array_size(ndr, &r->attribute_name)) {
11486                                 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));
11487                         }
11488                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t)));
11489                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->attribute_name, ndr_get_array_length(ndr, &r->attribute_name), sizeof(uint16_t), CH_UTF16));
11490                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attribute_name_0, 0);
11491                 }
11492                 if (r->object_dn) {
11493                         _mem_save_object_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11494                         NDR_PULL_SET_MEM_CTX(ndr, r->object_dn, 0);
11495                         NDR_CHECK(ndr_pull_array_size(ndr, &r->object_dn));
11496                         NDR_CHECK(ndr_pull_array_length(ndr, &r->object_dn));
11497                         if (ndr_get_array_length(ndr, &r->object_dn) > ndr_get_array_size(ndr, &r->object_dn)) {
11498                                 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));
11499                         }
11500                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t)));
11501                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->object_dn, ndr_get_array_length(ndr, &r->object_dn), sizeof(uint16_t), CH_UTF16));
11502                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_object_dn_0, 0);
11503                 }
11504                 if (r->binary) {
11505                         _mem_save_binary_0 = NDR_PULL_GET_MEM_CTX(ndr);
11506                         NDR_PULL_SET_MEM_CTX(ndr, r->binary, 0);
11507                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
11508                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_binary_0, 0);
11509                 }
11510                 if (r->originating_dsa_dn) {
11511                         _mem_save_originating_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr);
11512                         NDR_PULL_SET_MEM_CTX(ndr, r->originating_dsa_dn, 0);
11513                         NDR_CHECK(ndr_pull_array_size(ndr, &r->originating_dsa_dn));
11514                         NDR_CHECK(ndr_pull_array_length(ndr, &r->originating_dsa_dn));
11515                         if (ndr_get_array_length(ndr, &r->originating_dsa_dn) > ndr_get_array_size(ndr, &r->originating_dsa_dn)) {
11516                                 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));
11517                         }
11518                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->originating_dsa_dn), sizeof(uint16_t)));
11519                         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));
11520                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_originating_dsa_dn_0, 0);
11521                 }
11522         }
11523         return NDR_ERR_SUCCESS;
11524 }
11525
11526 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2 *r)
11527 {
11528         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2");
11529         ndr->depth++;
11530         ndr_print_ptr(ndr, "attribute_name", r->attribute_name);
11531         ndr->depth++;
11532         if (r->attribute_name) {
11533                 ndr_print_string(ndr, "attribute_name", r->attribute_name);
11534         }
11535         ndr->depth--;
11536         ndr_print_ptr(ndr, "object_dn", r->object_dn);
11537         ndr->depth++;
11538         if (r->object_dn) {
11539                 ndr_print_string(ndr, "object_dn", r->object_dn);
11540         }
11541         ndr->depth--;
11542         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);
11543         ndr_print_ptr(ndr, "binary", r->binary);
11544         ndr->depth++;
11545         if (r->binary) {
11546                 ndr_print_DATA_BLOB(ndr, "binary", *r->binary);
11547         }
11548         ndr->depth--;
11549         ndr_print_NTTIME(ndr, "deleted", r->deleted);
11550         ndr_print_NTTIME(ndr, "created", r->created);
11551         ndr_print_uint32(ndr, "version", r->version);
11552         ndr_print_NTTIME(ndr, "originating_change_time", r->originating_change_time);
11553         ndr_print_GUID(ndr, "originating_invocation_id", &r->originating_invocation_id);
11554         ndr_print_hyper(ndr, "originating_usn", r->originating_usn);
11555         ndr_print_hyper(ndr, "local_usn", r->local_usn);
11556         ndr_print_ptr(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11557         ndr->depth++;
11558         if (r->originating_dsa_dn) {
11559                 ndr_print_string(ndr, "originating_dsa_dn", r->originating_dsa_dn);
11560         }
11561         ndr->depth--;
11562         ndr->depth--;
11563 }
11564
11565 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11566 {
11567         uint32_t cntr_array_0;
11568         if (ndr_flags & NDR_SCALARS) {
11569                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11570                 NDR_CHECK(ndr_push_align(ndr, 8));
11571                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumeration_context));
11573                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11574                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11575                 }
11576                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11577         }
11578         if (ndr_flags & NDR_BUFFERS) {
11579                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11580                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11581                 }
11582         }
11583         return NDR_ERR_SUCCESS;
11584 }
11585
11586 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11587 {
11588         uint32_t cntr_array_0;
11589         TALLOC_CTX *_mem_save_array_0;
11590         if (ndr_flags & NDR_SCALARS) {
11591                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11592                 NDR_CHECK(ndr_pull_align(ndr, 8));
11593                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11594                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumeration_context));
11595                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11596                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11597                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11598                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11599                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11600                 }
11601                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11602                 if (r->array) {
11603                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11604                 }
11605                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11606         }
11607         if (ndr_flags & NDR_BUFFERS) {
11608                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11609                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11610                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11611                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11612                 }
11613                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11614         }
11615         return NDR_ERR_SUCCESS;
11616 }
11617
11618 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAttrValMetaData2Ctr *r)
11619 {
11620         uint32_t cntr_array_0;
11621         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttrValMetaData2Ctr");
11622         ndr->depth++;
11623         ndr_print_uint32(ndr, "count", r->count);
11624         ndr_print_uint32(ndr, "enumeration_context", r->enumeration_context);
11625         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11626         ndr->depth++;
11627         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11628                 char *idx_0=NULL;
11629                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11630                         ndr_print_drsuapi_DsReplicaAttrValMetaData2(ndr, "array", &r->array[cntr_array_0]);
11631                         free(idx_0);
11632                 }
11633         }
11634         ndr->depth--;
11635         ndr->depth--;
11636 }
11637
11638 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04 *r)
11639 {
11640         if (ndr_flags & NDR_SCALARS) {
11641                 NDR_CHECK(ndr_push_align(ndr, 8));
11642                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u1));
11643                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11645                 NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11646                 NDR_CHECK(ndr_push_NTTIME_1sec(ndr, NDR_SCALARS, r->bind_time));
11647                 {
11648                         uint32_t _flags_save_ipv4address = ndr->flags;
11649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11650                         NDR_CHECK(ndr_push_ipv4address(ndr, NDR_SCALARS, r->client_ip_address));
11651                         ndr->flags = _flags_save_ipv4address;
11652                 }
11653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11654                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11655         }
11656         if (ndr_flags & NDR_BUFFERS) {
11657         }
11658         return NDR_ERR_SUCCESS;
11659 }
11660
11661 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04 *r)
11662 {
11663         if (ndr_flags & NDR_SCALARS) {
11664                 NDR_CHECK(ndr_pull_align(ndr, 8));
11665                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u1));
11666                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11667                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11668                 NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->bind_guid));
11669                 NDR_CHECK(ndr_pull_NTTIME_1sec(ndr, NDR_SCALARS, &r->bind_time));
11670                 {
11671                         uint32_t _flags_save_ipv4address = ndr->flags;
11672                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
11673                         NDR_CHECK(ndr_pull_ipv4address(ndr, NDR_SCALARS, &r->client_ip_address));
11674                         ndr->flags = _flags_save_ipv4address;
11675                 }
11676                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11677                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11678         }
11679         if (ndr_flags & NDR_BUFFERS) {
11680         }
11681         return NDR_ERR_SUCCESS;
11682 }
11683
11684 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04 *r)
11685 {
11686         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04");
11687         ndr->depth++;
11688         ndr_print_hyper(ndr, "u1", r->u1);
11689         ndr_print_uint32(ndr, "u2", r->u2);
11690         ndr_print_uint32(ndr, "u3", r->u3);
11691         ndr_print_GUID(ndr, "bind_guid", &r->bind_guid);
11692         ndr_print_NTTIME_1sec(ndr, "bind_time", r->bind_time);
11693         ndr_print_ipv4address(ndr, "client_ip_address", r->client_ip_address);
11694         ndr_print_uint32(ndr, "u5", r->u5);
11695         ndr->depth--;
11696 }
11697
11698 static enum ndr_err_code ndr_push_drsuapi_DsReplicaConnection04Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaConnection04Ctr *r)
11699 {
11700         uint32_t cntr_array_0;
11701         if (ndr_flags & NDR_SCALARS) {
11702                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->count));
11703                 NDR_CHECK(ndr_push_align(ndr, 8));
11704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
11705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
11706                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11707                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11708                 }
11709                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11710         }
11711         if (ndr_flags & NDR_BUFFERS) {
11712         }
11713         return NDR_ERR_SUCCESS;
11714 }
11715
11716 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaConnection04Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaConnection04Ctr *r)
11717 {
11718         uint32_t cntr_array_0;
11719         TALLOC_CTX *_mem_save_array_0;
11720         if (ndr_flags & NDR_SCALARS) {
11721                 NDR_CHECK(ndr_pull_array_size(ndr, &r->array));
11722                 NDR_CHECK(ndr_pull_align(ndr, 8));
11723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
11724                 if (r->count > 10000) {
11725                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11726                 }
11727                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11728                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11729                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11730                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11731                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11732                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11733                 }
11734                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11735                 if (r->array) {
11736                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11737                 }
11738                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11739         }
11740         if (ndr_flags & NDR_BUFFERS) {
11741         }
11742         return NDR_ERR_SUCCESS;
11743 }
11744
11745 _PUBLIC_ void ndr_print_drsuapi_DsReplicaConnection04Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaConnection04Ctr *r)
11746 {
11747         uint32_t cntr_array_0;
11748         ndr_print_struct(ndr, name, "drsuapi_DsReplicaConnection04Ctr");
11749         ndr->depth++;
11750         ndr_print_uint32(ndr, "count", r->count);
11751         ndr_print_uint32(ndr, "reserved", r->reserved);
11752         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11753         ndr->depth++;
11754         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11755                 char *idx_0=NULL;
11756                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11757                         ndr_print_drsuapi_DsReplicaConnection04(ndr, "array", &r->array[cntr_array_0]);
11758                         free(idx_0);
11759                 }
11760         }
11761         ndr->depth--;
11762         ndr->depth--;
11763 }
11764
11765 static enum ndr_err_code ndr_push_drsuapi_DsReplica06(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06 *r)
11766 {
11767         if (ndr_flags & NDR_SCALARS) {
11768                 NDR_CHECK(ndr_push_align(ndr, 8));
11769                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->str1));
11770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u1));
11771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
11772                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
11773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u4));
11774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u5));
11775                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->u6));
11776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u7));
11777                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
11778         }
11779         if (ndr_flags & NDR_BUFFERS) {
11780                 if (r->str1) {
11781                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11782                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
11783                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->str1, CH_UTF16)));
11784                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->str1, ndr_charset_length(r->str1, CH_UTF16), sizeof(uint16_t), CH_UTF16));
11785                 }
11786         }
11787         return NDR_ERR_SUCCESS;
11788 }
11789
11790 static enum ndr_err_code ndr_pull_drsuapi_DsReplica06(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06 *r)
11791 {
11792         uint32_t _ptr_str1;
11793         TALLOC_CTX *_mem_save_str1_0;
11794         if (ndr_flags & NDR_SCALARS) {
11795                 NDR_CHECK(ndr_pull_align(ndr, 8));
11796                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str1));
11797                 if (_ptr_str1) {
11798                         NDR_PULL_ALLOC(ndr, r->str1);
11799                 } else {
11800                         r->str1 = NULL;
11801                 }
11802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u1));
11803                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
11804                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
11805                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u4));
11806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u5));
11807                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->u6));
11808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u7));
11809                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11810         }
11811         if (ndr_flags & NDR_BUFFERS) {
11812                 if (r->str1) {
11813                         _mem_save_str1_0 = NDR_PULL_GET_MEM_CTX(ndr);
11814                         NDR_PULL_SET_MEM_CTX(ndr, r->str1, 0);
11815                         NDR_CHECK(ndr_pull_array_size(ndr, &r->str1));
11816                         NDR_CHECK(ndr_pull_array_length(ndr, &r->str1));
11817                         if (ndr_get_array_length(ndr, &r->str1) > ndr_get_array_size(ndr, &r->str1)) {
11818                                 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));
11819                         }
11820                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t)));
11821                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->str1, ndr_get_array_length(ndr, &r->str1), sizeof(uint16_t), CH_UTF16));
11822                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str1_0, 0);
11823                 }
11824         }
11825         return NDR_ERR_SUCCESS;
11826 }
11827
11828 _PUBLIC_ void ndr_print_drsuapi_DsReplica06(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06 *r)
11829 {
11830         ndr_print_struct(ndr, name, "drsuapi_DsReplica06");
11831         ndr->depth++;
11832         ndr_print_ptr(ndr, "str1", r->str1);
11833         ndr->depth++;
11834         if (r->str1) {
11835                 ndr_print_string(ndr, "str1", r->str1);
11836         }
11837         ndr->depth--;
11838         ndr_print_uint32(ndr, "u1", r->u1);
11839         ndr_print_uint32(ndr, "u2", r->u2);
11840         ndr_print_uint32(ndr, "u3", r->u3);
11841         ndr_print_uint32(ndr, "u4", r->u4);
11842         ndr_print_uint32(ndr, "u5", r->u5);
11843         ndr_print_hyper(ndr, "u6", r->u6);
11844         ndr_print_uint32(ndr, "u7", r->u7);
11845         ndr->depth--;
11846 }
11847
11848 static enum ndr_err_code ndr_push_drsuapi_DsReplica06Ctr(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplica06Ctr *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_uint32(ndr, NDR_SCALARS, r->reserved));
11856                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11857                         NDR_CHECK(ndr_push_drsuapi_DsReplica06(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_DsReplica06(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_DsReplica06Ctr(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplica06Ctr *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                 if (r->count > 256) {
11878                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
11879                 }
11880                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
11881                 NDR_PULL_ALLOC_N(ndr, r->array, ndr_get_array_size(ndr, &r->array));
11882                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11883                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11884                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11885                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
11886                 }
11887                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11888                 if (r->array) {
11889                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->array, r->count));
11890                 }
11891                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
11892         }
11893         if (ndr_flags & NDR_BUFFERS) {
11894                 _mem_save_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
11895                 NDR_PULL_SET_MEM_CTX(ndr, r->array, 0);
11896                 for (cntr_array_0 = 0; cntr_array_0 < r->count; cntr_array_0++) {
11897                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06(ndr, NDR_BUFFERS, &r->array[cntr_array_0]));
11898                 }
11899                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_array_0, 0);
11900         }
11901         return NDR_ERR_SUCCESS;
11902 }
11903
11904 _PUBLIC_ void ndr_print_drsuapi_DsReplica06Ctr(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplica06Ctr *r)
11905 {
11906         uint32_t cntr_array_0;
11907         ndr_print_struct(ndr, name, "drsuapi_DsReplica06Ctr");
11908         ndr->depth++;
11909         ndr_print_uint32(ndr, "count", r->count);
11910         ndr_print_uint32(ndr, "reserved", r->reserved);
11911         ndr->print(ndr, "%s: ARRAY(%d)", "array", (int)r->count);
11912         ndr->depth++;
11913         for (cntr_array_0=0;cntr_array_0<r->count;cntr_array_0++) {
11914                 char *idx_0=NULL;
11915                 if (asprintf(&idx_0, "[%d]", cntr_array_0) != -1) {
11916                         ndr_print_drsuapi_DsReplica06(ndr, "array", &r->array[cntr_array_0]);
11917                         free(idx_0);
11918                 }
11919         }
11920         ndr->depth--;
11921         ndr->depth--;
11922 }
11923
11924 static enum ndr_err_code ndr_push_drsuapi_DsReplicaInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaInfo *r)
11925 {
11926         if (ndr_flags & NDR_SCALARS) {
11927                 int level = ndr_push_get_switch_value(ndr, r);
11928                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, level));
11929                 NDR_CHECK(ndr_push_union_align(ndr, 5));
11930                 switch (level) {
11931                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
11932                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours));
11933                         break; }
11934
11935                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
11936                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors));
11937                         break; }
11938
11939                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
11940                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata));
11941                         break; }
11942
11943                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
11944                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connectfailures));
11945                         break; }
11946
11947                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
11948                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->linkfailures));
11949                         break; }
11950
11951                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
11952                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->pendingops));
11953                         break; }
11954
11955                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
11956                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata));
11957                         break; }
11958
11959                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
11960                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors2));
11961                         break; }
11962
11963                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
11964                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors3));
11965                         break; }
11966
11967                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
11968                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->objmetadata2));
11969                         break; }
11970
11971                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
11972                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->attrvalmetadata2));
11973                         break; }
11974
11975                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
11976                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->neighbours02));
11977                         break; }
11978
11979                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
11980                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->connections04));
11981                         break; }
11982
11983                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
11984                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->cursors05));
11985                         break; }
11986
11987                         case DRSUAPI_DS_REPLICA_INFO_06: {
11988                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->i06));
11989                         break; }
11990
11991                         default:
11992                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
11993                 }
11994         }
11995         if (ndr_flags & NDR_BUFFERS) {
11996                 int level = ndr_push_get_switch_value(ndr, r);
11997                 switch (level) {
11998                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
11999                                 if (r->neighbours) {
12000                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12001                                 }
12002                         break;
12003
12004                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12005                                 if (r->cursors) {
12006                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12007                                 }
12008                         break;
12009
12010                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12011                                 if (r->objmetadata) {
12012                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12013                                 }
12014                         break;
12015
12016                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12017                                 if (r->connectfailures) {
12018                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12019                                 }
12020                         break;
12021
12022                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12023                                 if (r->linkfailures) {
12024                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12025                                 }
12026                         break;
12027
12028                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12029                                 if (r->pendingops) {
12030                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12031                                 }
12032                         break;
12033
12034                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12035                                 if (r->attrvalmetadata) {
12036                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12037                                 }
12038                         break;
12039
12040                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12041                                 if (r->cursors2) {
12042                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12043                                 }
12044                         break;
12045
12046                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12047                                 if (r->cursors3) {
12048                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12049                                 }
12050                         break;
12051
12052                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12053                                 if (r->objmetadata2) {
12054                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12055                                 }
12056                         break;
12057
12058                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12059                                 if (r->attrvalmetadata2) {
12060                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12061                                 }
12062                         break;
12063
12064                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12065                                 if (r->neighbours02) {
12066                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12067                                 }
12068                         break;
12069
12070                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12071                                 if (r->connections04) {
12072                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12073                                 }
12074                         break;
12075
12076                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12077                                 if (r->cursors05) {
12078                                         NDR_CHECK(ndr_push_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12079                                 }
12080                         break;
12081
12082                         case DRSUAPI_DS_REPLICA_INFO_06:
12083                                 if (r->i06) {
12084                                         NDR_CHECK(ndr_push_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12085                                 }
12086                         break;
12087
12088                         default:
12089                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12090                 }
12091         }
12092         return NDR_ERR_SUCCESS;
12093 }
12094
12095 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaInfo *r)
12096 {
12097         int level;
12098         uint32_t _level;
12099         TALLOC_CTX *_mem_save_neighbours_0;
12100         TALLOC_CTX *_mem_save_cursors_0;
12101         TALLOC_CTX *_mem_save_objmetadata_0;
12102         TALLOC_CTX *_mem_save_connectfailures_0;
12103         TALLOC_CTX *_mem_save_linkfailures_0;
12104         TALLOC_CTX *_mem_save_pendingops_0;
12105         TALLOC_CTX *_mem_save_attrvalmetadata_0;
12106         TALLOC_CTX *_mem_save_cursors2_0;
12107         TALLOC_CTX *_mem_save_cursors3_0;
12108         TALLOC_CTX *_mem_save_objmetadata2_0;
12109         TALLOC_CTX *_mem_save_attrvalmetadata2_0;
12110         TALLOC_CTX *_mem_save_neighbours02_0;
12111         TALLOC_CTX *_mem_save_connections04_0;
12112         TALLOC_CTX *_mem_save_cursors05_0;
12113         TALLOC_CTX *_mem_save_i06_0;
12114         level = ndr_pull_get_switch_value(ndr, r);
12115         if (ndr_flags & NDR_SCALARS) {
12116                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12117                 if (_level != level) {
12118                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12119                 }
12120                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12121                 switch (level) {
12122                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS: {
12123                                 uint32_t _ptr_neighbours;
12124                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours));
12125                                 if (_ptr_neighbours) {
12126                                         NDR_PULL_ALLOC(ndr, r->neighbours);
12127                                 } else {
12128                                         r->neighbours = NULL;
12129                                 }
12130                         break; }
12131
12132                         case DRSUAPI_DS_REPLICA_INFO_CURSORS: {
12133                                 uint32_t _ptr_cursors;
12134                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors));
12135                                 if (_ptr_cursors) {
12136                                         NDR_PULL_ALLOC(ndr, r->cursors);
12137                                 } else {
12138                                         r->cursors = NULL;
12139                                 }
12140                         break; }
12141
12142                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: {
12143                                 uint32_t _ptr_objmetadata;
12144                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata));
12145                                 if (_ptr_objmetadata) {
12146                                         NDR_PULL_ALLOC(ndr, r->objmetadata);
12147                                 } else {
12148                                         r->objmetadata = NULL;
12149                                 }
12150                         break; }
12151
12152                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: {
12153                                 uint32_t _ptr_connectfailures;
12154                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connectfailures));
12155                                 if (_ptr_connectfailures) {
12156                                         NDR_PULL_ALLOC(ndr, r->connectfailures);
12157                                 } else {
12158                                         r->connectfailures = NULL;
12159                                 }
12160                         break; }
12161
12162                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: {
12163                                 uint32_t _ptr_linkfailures;
12164                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_linkfailures));
12165                                 if (_ptr_linkfailures) {
12166                                         NDR_PULL_ALLOC(ndr, r->linkfailures);
12167                                 } else {
12168                                         r->linkfailures = NULL;
12169                                 }
12170                         break; }
12171
12172                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: {
12173                                 uint32_t _ptr_pendingops;
12174                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_pendingops));
12175                                 if (_ptr_pendingops) {
12176                                         NDR_PULL_ALLOC(ndr, r->pendingops);
12177                                 } else {
12178                                         r->pendingops = NULL;
12179                                 }
12180                         break; }
12181
12182                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: {
12183                                 uint32_t _ptr_attrvalmetadata;
12184                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata));
12185                                 if (_ptr_attrvalmetadata) {
12186                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata);
12187                                 } else {
12188                                         r->attrvalmetadata = NULL;
12189                                 }
12190                         break; }
12191
12192                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: {
12193                                 uint32_t _ptr_cursors2;
12194                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors2));
12195                                 if (_ptr_cursors2) {
12196                                         NDR_PULL_ALLOC(ndr, r->cursors2);
12197                                 } else {
12198                                         r->cursors2 = NULL;
12199                                 }
12200                         break; }
12201
12202                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: {
12203                                 uint32_t _ptr_cursors3;
12204                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors3));
12205                                 if (_ptr_cursors3) {
12206                                         NDR_PULL_ALLOC(ndr, r->cursors3);
12207                                 } else {
12208                                         r->cursors3 = NULL;
12209                                 }
12210                         break; }
12211
12212                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: {
12213                                 uint32_t _ptr_objmetadata2;
12214                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_objmetadata2));
12215                                 if (_ptr_objmetadata2) {
12216                                         NDR_PULL_ALLOC(ndr, r->objmetadata2);
12217                                 } else {
12218                                         r->objmetadata2 = NULL;
12219                                 }
12220                         break; }
12221
12222                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: {
12223                                 uint32_t _ptr_attrvalmetadata2;
12224                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_attrvalmetadata2));
12225                                 if (_ptr_attrvalmetadata2) {
12226                                         NDR_PULL_ALLOC(ndr, r->attrvalmetadata2);
12227                                 } else {
12228                                         r->attrvalmetadata2 = NULL;
12229                                 }
12230                         break; }
12231
12232                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: {
12233                                 uint32_t _ptr_neighbours02;
12234                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_neighbours02));
12235                                 if (_ptr_neighbours02) {
12236                                         NDR_PULL_ALLOC(ndr, r->neighbours02);
12237                                 } else {
12238                                         r->neighbours02 = NULL;
12239                                 }
12240                         break; }
12241
12242                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: {
12243                                 uint32_t _ptr_connections04;
12244                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_connections04));
12245                                 if (_ptr_connections04) {
12246                                         NDR_PULL_ALLOC(ndr, r->connections04);
12247                                 } else {
12248                                         r->connections04 = NULL;
12249                                 }
12250                         break; }
12251
12252                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: {
12253                                 uint32_t _ptr_cursors05;
12254                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_cursors05));
12255                                 if (_ptr_cursors05) {
12256                                         NDR_PULL_ALLOC(ndr, r->cursors05);
12257                                 } else {
12258                                         r->cursors05 = NULL;
12259                                 }
12260                         break; }
12261
12262                         case DRSUAPI_DS_REPLICA_INFO_06: {
12263                                 uint32_t _ptr_i06;
12264                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_i06));
12265                                 if (_ptr_i06) {
12266                                         NDR_PULL_ALLOC(ndr, r->i06);
12267                                 } else {
12268                                         r->i06 = NULL;
12269                                 }
12270                         break; }
12271
12272                         default:
12273                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12274                 }
12275         }
12276         if (ndr_flags & NDR_BUFFERS) {
12277                 switch (level) {
12278                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12279                                 if (r->neighbours) {
12280                                         _mem_save_neighbours_0 = NDR_PULL_GET_MEM_CTX(ndr);
12281                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours, 0);
12282                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours));
12283                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours_0, 0);
12284                                 }
12285                         break;
12286
12287                         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12288                                 if (r->cursors) {
12289                                         _mem_save_cursors_0 = NDR_PULL_GET_MEM_CTX(ndr);
12290                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors, 0);
12291                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtr(ndr, NDR_SCALARS, r->cursors));
12292                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors_0, 0);
12293                                 }
12294                         break;
12295
12296                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12297                                 if (r->objmetadata) {
12298                                         _mem_save_objmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12299                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata, 0);
12300                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata));
12301                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata_0, 0);
12302                                 }
12303                         break;
12304
12305                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12306                                 if (r->connectfailures) {
12307                                         _mem_save_connectfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12308                                         NDR_PULL_SET_MEM_CTX(ndr, r->connectfailures, 0);
12309                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->connectfailures));
12310                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connectfailures_0, 0);
12311                                 }
12312                         break;
12313
12314                         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12315                                 if (r->linkfailures) {
12316                                         _mem_save_linkfailures_0 = NDR_PULL_GET_MEM_CTX(ndr);
12317                                         NDR_PULL_SET_MEM_CTX(ndr, r->linkfailures, 0);
12318                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->linkfailures));
12319                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_linkfailures_0, 0);
12320                                 }
12321                         break;
12322
12323                         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12324                                 if (r->pendingops) {
12325                                         _mem_save_pendingops_0 = NDR_PULL_GET_MEM_CTX(ndr);
12326                                         NDR_PULL_SET_MEM_CTX(ndr, r->pendingops, 0);
12327                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaOpCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->pendingops));
12328                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_pendingops_0, 0);
12329                                 }
12330                         break;
12331
12332                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12333                                 if (r->attrvalmetadata) {
12334                                         _mem_save_attrvalmetadata_0 = NDR_PULL_GET_MEM_CTX(ndr);
12335                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata, 0);
12336                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata));
12337                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata_0, 0);
12338                                 }
12339                         break;
12340
12341                         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12342                                 if (r->cursors2) {
12343                                         _mem_save_cursors2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12344                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors2, 0);
12345                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor2Ctr(ndr, NDR_SCALARS, r->cursors2));
12346                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors2_0, 0);
12347                                 }
12348                         break;
12349
12350                         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12351                                 if (r->cursors3) {
12352                                         _mem_save_cursors3_0 = NDR_PULL_GET_MEM_CTX(ndr);
12353                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors3, 0);
12354                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursor3Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->cursors3));
12355                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors3_0, 0);
12356                                 }
12357                         break;
12358
12359                         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12360                                 if (r->objmetadata2) {
12361                                         _mem_save_objmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12362                                         NDR_PULL_SET_MEM_CTX(ndr, r->objmetadata2, 0);
12363                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->objmetadata2));
12364                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_objmetadata2_0, 0);
12365                                 }
12366                         break;
12367
12368                         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12369                                 if (r->attrvalmetadata2) {
12370                                         _mem_save_attrvalmetadata2_0 = NDR_PULL_GET_MEM_CTX(ndr);
12371                                         NDR_PULL_SET_MEM_CTX(ndr, r->attrvalmetadata2, 0);
12372                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->attrvalmetadata2));
12373                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_attrvalmetadata2_0, 0);
12374                                 }
12375                         break;
12376
12377                         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12378                                 if (r->neighbours02) {
12379                                         _mem_save_neighbours02_0 = NDR_PULL_GET_MEM_CTX(ndr);
12380                                         NDR_PULL_SET_MEM_CTX(ndr, r->neighbours02, 0);
12381                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaNeighbourCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->neighbours02));
12382                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_neighbours02_0, 0);
12383                                 }
12384                         break;
12385
12386                         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12387                                 if (r->connections04) {
12388                                         _mem_save_connections04_0 = NDR_PULL_GET_MEM_CTX(ndr);
12389                                         NDR_PULL_SET_MEM_CTX(ndr, r->connections04, 0);
12390                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaConnection04Ctr(ndr, NDR_SCALARS, r->connections04));
12391                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_connections04_0, 0);
12392                                 }
12393                         break;
12394
12395                         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12396                                 if (r->cursors05) {
12397                                         _mem_save_cursors05_0 = NDR_PULL_GET_MEM_CTX(ndr);
12398                                         NDR_PULL_SET_MEM_CTX(ndr, r->cursors05, 0);
12399                                         NDR_CHECK(ndr_pull_drsuapi_DsReplicaCursorCtrEx(ndr, NDR_SCALARS, r->cursors05));
12400                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_cursors05_0, 0);
12401                                 }
12402                         break;
12403
12404                         case DRSUAPI_DS_REPLICA_INFO_06:
12405                                 if (r->i06) {
12406                                         _mem_save_i06_0 = NDR_PULL_GET_MEM_CTX(ndr);
12407                                         NDR_PULL_SET_MEM_CTX(ndr, r->i06, 0);
12408                                         NDR_CHECK(ndr_pull_drsuapi_DsReplica06Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->i06));
12409                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_i06_0, 0);
12410                                 }
12411                         break;
12412
12413                         default:
12414                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12415                 }
12416         }
12417         return NDR_ERR_SUCCESS;
12418 }
12419
12420 _PUBLIC_ void ndr_print_drsuapi_DsReplicaInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaInfo *r)
12421 {
12422         int level;
12423         level = ndr_print_get_switch_value(ndr, r);
12424         ndr_print_union(ndr, name, level, "drsuapi_DsReplicaInfo");
12425         switch (level) {
12426                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
12427                         ndr_print_ptr(ndr, "neighbours", r->neighbours);
12428                         ndr->depth++;
12429                         if (r->neighbours) {
12430                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours", r->neighbours);
12431                         }
12432                         ndr->depth--;
12433                 break;
12434
12435                 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
12436                         ndr_print_ptr(ndr, "cursors", r->cursors);
12437                         ndr->depth++;
12438                         if (r->cursors) {
12439                                 ndr_print_drsuapi_DsReplicaCursorCtr(ndr, "cursors", r->cursors);
12440                         }
12441                         ndr->depth--;
12442                 break;
12443
12444                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
12445                         ndr_print_ptr(ndr, "objmetadata", r->objmetadata);
12446                         ndr->depth++;
12447                         if (r->objmetadata) {
12448                                 ndr_print_drsuapi_DsReplicaObjMetaDataCtr(ndr, "objmetadata", r->objmetadata);
12449                         }
12450                         ndr->depth--;
12451                 break;
12452
12453                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
12454                         ndr_print_ptr(ndr, "connectfailures", r->connectfailures);
12455                         ndr->depth++;
12456                         if (r->connectfailures) {
12457                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "connectfailures", r->connectfailures);
12458                         }
12459                         ndr->depth--;
12460                 break;
12461
12462                 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
12463                         ndr_print_ptr(ndr, "linkfailures", r->linkfailures);
12464                         ndr->depth++;
12465                         if (r->linkfailures) {
12466                                 ndr_print_drsuapi_DsReplicaKccDsaFailuresCtr(ndr, "linkfailures", r->linkfailures);
12467                         }
12468                         ndr->depth--;
12469                 break;
12470
12471                 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
12472                         ndr_print_ptr(ndr, "pendingops", r->pendingops);
12473                         ndr->depth++;
12474                         if (r->pendingops) {
12475                                 ndr_print_drsuapi_DsReplicaOpCtr(ndr, "pendingops", r->pendingops);
12476                         }
12477                         ndr->depth--;
12478                 break;
12479
12480                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
12481                         ndr_print_ptr(ndr, "attrvalmetadata", r->attrvalmetadata);
12482                         ndr->depth++;
12483                         if (r->attrvalmetadata) {
12484                                 ndr_print_drsuapi_DsReplicaAttrValMetaDataCtr(ndr, "attrvalmetadata", r->attrvalmetadata);
12485                         }
12486                         ndr->depth--;
12487                 break;
12488
12489                 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
12490                         ndr_print_ptr(ndr, "cursors2", r->cursors2);
12491                         ndr->depth++;
12492                         if (r->cursors2) {
12493                                 ndr_print_drsuapi_DsReplicaCursor2Ctr(ndr, "cursors2", r->cursors2);
12494                         }
12495                         ndr->depth--;
12496                 break;
12497
12498                 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
12499                         ndr_print_ptr(ndr, "cursors3", r->cursors3);
12500                         ndr->depth++;
12501                         if (r->cursors3) {
12502                                 ndr_print_drsuapi_DsReplicaCursor3Ctr(ndr, "cursors3", r->cursors3);
12503                         }
12504                         ndr->depth--;
12505                 break;
12506
12507                 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
12508                         ndr_print_ptr(ndr, "objmetadata2", r->objmetadata2);
12509                         ndr->depth++;
12510                         if (r->objmetadata2) {
12511                                 ndr_print_drsuapi_DsReplicaObjMetaData2Ctr(ndr, "objmetadata2", r->objmetadata2);
12512                         }
12513                         ndr->depth--;
12514                 break;
12515
12516                 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
12517                         ndr_print_ptr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12518                         ndr->depth++;
12519                         if (r->attrvalmetadata2) {
12520                                 ndr_print_drsuapi_DsReplicaAttrValMetaData2Ctr(ndr, "attrvalmetadata2", r->attrvalmetadata2);
12521                         }
12522                         ndr->depth--;
12523                 break;
12524
12525                 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
12526                         ndr_print_ptr(ndr, "neighbours02", r->neighbours02);
12527                         ndr->depth++;
12528                         if (r->neighbours02) {
12529                                 ndr_print_drsuapi_DsReplicaNeighbourCtr(ndr, "neighbours02", r->neighbours02);
12530                         }
12531                         ndr->depth--;
12532                 break;
12533
12534                 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
12535                         ndr_print_ptr(ndr, "connections04", r->connections04);
12536                         ndr->depth++;
12537                         if (r->connections04) {
12538                                 ndr_print_drsuapi_DsReplicaConnection04Ctr(ndr, "connections04", r->connections04);
12539                         }
12540                         ndr->depth--;
12541                 break;
12542
12543                 case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
12544                         ndr_print_ptr(ndr, "cursors05", r->cursors05);
12545                         ndr->depth++;
12546                         if (r->cursors05) {
12547                                 ndr_print_drsuapi_DsReplicaCursorCtrEx(ndr, "cursors05", r->cursors05);
12548                         }
12549                         ndr->depth--;
12550                 break;
12551
12552                 case DRSUAPI_DS_REPLICA_INFO_06:
12553                         ndr_print_ptr(ndr, "i06", r->i06);
12554                         ndr->depth++;
12555                         if (r->i06) {
12556                                 ndr_print_drsuapi_DsReplica06Ctr(ndr, "i06", r->i06);
12557                         }
12558                         ndr->depth--;
12559                 break;
12560
12561                 default:
12562                         ndr_print_bad_level(ndr, name, level);
12563         }
12564 }
12565
12566 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Ctr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Ctr *r)
12567 {
12568         if (ndr_flags & NDR_SCALARS) {
12569                 int level = ndr_push_get_switch_value(ndr, r);
12570                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12571                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12572                 switch (level) {
12573                         case 1: {
12574                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12575                         break; }
12576
12577                         default:
12578                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12579                 }
12580         }
12581         if (ndr_flags & NDR_BUFFERS) {
12582                 int level = ndr_push_get_switch_value(ndr, r);
12583                 switch (level) {
12584                         case 1:
12585                                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12586                         break;
12587
12588                         default:
12589                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12590                 }
12591         }
12592         return NDR_ERR_SUCCESS;
12593 }
12594
12595 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Ctr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Ctr *r)
12596 {
12597         int level;
12598         int32_t _level;
12599         level = ndr_pull_get_switch_value(ndr, r);
12600         if (ndr_flags & NDR_SCALARS) {
12601                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12602                 if (_level != level) {
12603                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12604                 }
12605                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12606                 switch (level) {
12607                         case 1: {
12608                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_SCALARS, &r->ctr1));
12609                         break; }
12610
12611                         default:
12612                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12613                 }
12614         }
12615         if (ndr_flags & NDR_BUFFERS) {
12616                 switch (level) {
12617                         case 1:
12618                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12619                         break;
12620
12621                         default:
12622                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12623                 }
12624         }
12625         return NDR_ERR_SUCCESS;
12626 }
12627
12628 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Ctr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Ctr *r)
12629 {
12630         int level;
12631         level = ndr_print_get_switch_value(ndr, r);
12632         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Ctr");
12633         switch (level) {
12634                 case 1:
12635                         ndr_print_drsuapi_DsGetMembershipsCtr1(ndr, "ctr1", &r->ctr1);
12636                 break;
12637
12638                 default:
12639                         ndr_print_bad_level(ndr, name, level);
12640         }
12641 }
12642
12643 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsGetMemberships2Request1 *r)
12644 {
12645         uint32_t cntr_req_array_1;
12646         if (ndr_flags & NDR_SCALARS) {
12647                 NDR_CHECK(ndr_push_align(ndr, 5));
12648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
12649                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array));
12650                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12651         }
12652         if (ndr_flags & NDR_BUFFERS) {
12653                 if (r->req_array) {
12654                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
12655                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12656                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->req_array[cntr_req_array_1]));
12657                         }
12658                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12659                                 if (r->req_array[cntr_req_array_1]) {
12660                                         NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12661                                 }
12662                         }
12663                 }
12664         }
12665         return NDR_ERR_SUCCESS;
12666 }
12667
12668 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsGetMemberships2Request1 *r)
12669 {
12670         uint32_t _ptr_req_array;
12671         uint32_t cntr_req_array_1;
12672         TALLOC_CTX *_mem_save_req_array_0;
12673         TALLOC_CTX *_mem_save_req_array_1;
12674         TALLOC_CTX *_mem_save_req_array_2;
12675         if (ndr_flags & NDR_SCALARS) {
12676                 NDR_CHECK(ndr_pull_align(ndr, 5));
12677                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
12678                 if (r->num_req < 1 || r->num_req > 10000) {
12679                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12680                 }
12681                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12682                 if (_ptr_req_array) {
12683                         NDR_PULL_ALLOC(ndr, r->req_array);
12684                 } else {
12685                         r->req_array = NULL;
12686                 }
12687                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12688         }
12689         if (ndr_flags & NDR_BUFFERS) {
12690                 if (r->req_array) {
12691                         _mem_save_req_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
12692                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12693                         NDR_CHECK(ndr_pull_array_size(ndr, &r->req_array));
12694                         NDR_PULL_ALLOC_N(ndr, r->req_array, ndr_get_array_size(ndr, &r->req_array));
12695                         _mem_save_req_array_1 = NDR_PULL_GET_MEM_CTX(ndr);
12696                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array, 0);
12697                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12698                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_req_array));
12699                                 if (_ptr_req_array) {
12700                                         NDR_PULL_ALLOC(ndr, r->req_array[cntr_req_array_1]);
12701                                 } else {
12702                                         r->req_array[cntr_req_array_1] = NULL;
12703                                 }
12704                         }
12705                         for (cntr_req_array_1 = 0; cntr_req_array_1 < r->num_req; cntr_req_array_1++) {
12706                                 if (r->req_array[cntr_req_array_1]) {
12707                                         _mem_save_req_array_2 = NDR_PULL_GET_MEM_CTX(ndr);
12708                                         NDR_PULL_SET_MEM_CTX(ndr, r->req_array[cntr_req_array_1], 0);
12709                                         NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest1(ndr, NDR_SCALARS|NDR_BUFFERS, r->req_array[cntr_req_array_1]));
12710                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_2, 0);
12711                                 }
12712                         }
12713                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_1, 0);
12714                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_array_0, 0);
12715                 }
12716                 if (r->req_array) {
12717                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->req_array, r->num_req));
12718                 }
12719         }
12720         return NDR_ERR_SUCCESS;
12721 }
12722
12723 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMemberships2Request1 *r)
12724 {
12725         uint32_t cntr_req_array_1;
12726         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2Request1");
12727         ndr->depth++;
12728         ndr_print_uint32(ndr, "num_req", r->num_req);
12729         ndr_print_ptr(ndr, "req_array", r->req_array);
12730         ndr->depth++;
12731         if (r->req_array) {
12732                 ndr->print(ndr, "%s: ARRAY(%d)", "req_array", (int)r->num_req);
12733                 ndr->depth++;
12734                 for (cntr_req_array_1=0;cntr_req_array_1<r->num_req;cntr_req_array_1++) {
12735                         char *idx_1=NULL;
12736                         if (asprintf(&idx_1, "[%d]", cntr_req_array_1) != -1) {
12737                                 ndr_print_ptr(ndr, "req_array", r->req_array[cntr_req_array_1]);
12738                                 ndr->depth++;
12739                                 if (r->req_array[cntr_req_array_1]) {
12740                                         ndr_print_drsuapi_DsGetMembershipsRequest1(ndr, "req_array", r->req_array[cntr_req_array_1]);
12741                                 }
12742                                 ndr->depth--;
12743                                 free(idx_1);
12744                         }
12745                 }
12746                 ndr->depth--;
12747         }
12748         ndr->depth--;
12749         ndr->depth--;
12750 }
12751
12752 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2Request(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsGetMemberships2Request *r)
12753 {
12754         if (ndr_flags & NDR_SCALARS) {
12755                 int level = ndr_push_get_switch_value(ndr, r);
12756                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12757                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12758                 switch (level) {
12759                         case 1: {
12760                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12761                         break; }
12762
12763                         default:
12764                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12765                 }
12766         }
12767         if (ndr_flags & NDR_BUFFERS) {
12768                 int level = ndr_push_get_switch_value(ndr, r);
12769                 switch (level) {
12770                         case 1:
12771                                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12772                         break;
12773
12774                         default:
12775                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12776                 }
12777         }
12778         return NDR_ERR_SUCCESS;
12779 }
12780
12781 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2Request(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsGetMemberships2Request *r)
12782 {
12783         int level;
12784         int32_t _level;
12785         level = ndr_pull_get_switch_value(ndr, r);
12786         if (ndr_flags & NDR_SCALARS) {
12787                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12788                 if (_level != level) {
12789                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12790                 }
12791                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12792                 switch (level) {
12793                         case 1: {
12794                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_SCALARS, &r->req1));
12795                         break; }
12796
12797                         default:
12798                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12799                 }
12800         }
12801         if (ndr_flags & NDR_BUFFERS) {
12802                 switch (level) {
12803                         case 1:
12804                                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request1(ndr, NDR_BUFFERS, &r->req1));
12805                         break;
12806
12807                         default:
12808                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12809                 }
12810         }
12811         return NDR_ERR_SUCCESS;
12812 }
12813
12814 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2Request(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMemberships2Request *r)
12815 {
12816         int level;
12817         level = ndr_print_get_switch_value(ndr, r);
12818         ndr_print_union(ndr, name, level, "drsuapi_DsGetMemberships2Request");
12819         switch (level) {
12820                 case 1:
12821                         ndr_print_drsuapi_DsGetMemberships2Request1(ndr, "req1", &r->req1);
12822                 break;
12823
12824                 default:
12825                         ndr_print_bad_level(ndr, name, level);
12826         }
12827 }
12828
12829 static enum ndr_err_code ndr_push_drsuapi_DsSiteCostInfo(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsSiteCostInfo *r)
12830 {
12831         if (ndr_flags & NDR_SCALARS) {
12832                 NDR_CHECK(ndr_push_align(ndr, 4));
12833                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->error_code));
12834                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->site_cost));
12835                 NDR_CHECK(ndr_push_trailer_align(ndr, 4));
12836         }
12837         if (ndr_flags & NDR_BUFFERS) {
12838         }
12839         return NDR_ERR_SUCCESS;
12840 }
12841
12842 static enum ndr_err_code ndr_pull_drsuapi_DsSiteCostInfo(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsSiteCostInfo *r)
12843 {
12844         if (ndr_flags & NDR_SCALARS) {
12845                 NDR_CHECK(ndr_pull_align(ndr, 4));
12846                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->error_code));
12847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->site_cost));
12848                 NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
12849         }
12850         if (ndr_flags & NDR_BUFFERS) {
12851         }
12852         return NDR_ERR_SUCCESS;
12853 }
12854
12855 _PUBLIC_ void ndr_print_drsuapi_DsSiteCostInfo(struct ndr_print *ndr, const char *name, const struct drsuapi_DsSiteCostInfo *r)
12856 {
12857         ndr_print_struct(ndr, name, "drsuapi_DsSiteCostInfo");
12858         ndr->depth++;
12859         ndr_print_WERROR(ndr, "error_code", r->error_code);
12860         ndr_print_uint32(ndr, "site_cost", r->site_cost);
12861         ndr->depth--;
12862 }
12863
12864 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostCtr1 *r)
12865 {
12866         uint32_t cntr_info_1;
12867         if (ndr_flags & NDR_SCALARS) {
12868                 NDR_CHECK(ndr_push_align(ndr, 5));
12869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_info));
12870                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info));
12871                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown));
12872                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
12873         }
12874         if (ndr_flags & NDR_BUFFERS) {
12875                 if (r->info) {
12876                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_info));
12877                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12878                                 NDR_CHECK(ndr_push_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12879                         }
12880                 }
12881         }
12882         return NDR_ERR_SUCCESS;
12883 }
12884
12885 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostCtr1 *r)
12886 {
12887         uint32_t _ptr_info;
12888         uint32_t cntr_info_1;
12889         TALLOC_CTX *_mem_save_info_0;
12890         TALLOC_CTX *_mem_save_info_1;
12891         if (ndr_flags & NDR_SCALARS) {
12892                 NDR_CHECK(ndr_pull_align(ndr, 5));
12893                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_info));
12894                 if (r->num_info > 10000) {
12895                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
12896                 }
12897                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12898                 if (_ptr_info) {
12899                         NDR_PULL_ALLOC(ndr, r->info);
12900                 } else {
12901                         r->info = NULL;
12902                 }
12903                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
12904                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
12905         }
12906         if (ndr_flags & NDR_BUFFERS) {
12907                 if (r->info) {
12908                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12909                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12910                         NDR_CHECK(ndr_pull_array_size(ndr, &r->info));
12911                         NDR_PULL_ALLOC_N(ndr, r->info, ndr_get_array_size(ndr, &r->info));
12912                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
12913                         NDR_PULL_SET_MEM_CTX(ndr, r->info, 0);
12914                         for (cntr_info_1 = 0; cntr_info_1 < r->num_info; cntr_info_1++) {
12915                                 NDR_CHECK(ndr_pull_drsuapi_DsSiteCostInfo(ndr, NDR_SCALARS, &r->info[cntr_info_1]));
12916                         }
12917                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
12918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12919                 }
12920                 if (r->info) {
12921                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->info, r->num_info));
12922                 }
12923         }
12924         return NDR_ERR_SUCCESS;
12925 }
12926
12927 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostCtr1 *r)
12928 {
12929         uint32_t cntr_info_1;
12930         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostCtr1");
12931         ndr->depth++;
12932         ndr_print_uint32(ndr, "num_info", r->num_info);
12933         ndr_print_ptr(ndr, "info", r->info);
12934         ndr->depth++;
12935         if (r->info) {
12936                 ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->num_info);
12937                 ndr->depth++;
12938                 for (cntr_info_1=0;cntr_info_1<r->num_info;cntr_info_1++) {
12939                         char *idx_1=NULL;
12940                         if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12941                                 ndr_print_drsuapi_DsSiteCostInfo(ndr, "info", &r->info[cntr_info_1]);
12942                                 free(idx_1);
12943                         }
12944                 }
12945                 ndr->depth--;
12946         }
12947         ndr->depth--;
12948         ndr_print_uint32(ndr, "unknown", r->unknown);
12949         ndr->depth--;
12950 }
12951
12952 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostCtr(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostCtr *r)
12953 {
12954         if (ndr_flags & NDR_SCALARS) {
12955                 int level = ndr_push_get_switch_value(ndr, r);
12956                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
12957                 NDR_CHECK(ndr_push_union_align(ndr, 5));
12958                 switch (level) {
12959                         case 1: {
12960                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12961                         break; }
12962
12963                         default:
12964                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12965                 }
12966         }
12967         if (ndr_flags & NDR_BUFFERS) {
12968                 int level = ndr_push_get_switch_value(ndr, r);
12969                 switch (level) {
12970                         case 1:
12971                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
12972                         break;
12973
12974                         default:
12975                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12976                 }
12977         }
12978         return NDR_ERR_SUCCESS;
12979 }
12980
12981 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostCtr(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostCtr *r)
12982 {
12983         int level;
12984         int32_t _level;
12985         level = ndr_pull_get_switch_value(ndr, r);
12986         if (ndr_flags & NDR_SCALARS) {
12987                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
12988                 if (_level != level) {
12989                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
12990                 }
12991                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
12992                 switch (level) {
12993                         case 1: {
12994                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_SCALARS, &r->ctr1));
12995                         break; }
12996
12997                         default:
12998                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
12999                 }
13000         }
13001         if (ndr_flags & NDR_BUFFERS) {
13002                 switch (level) {
13003                         case 1:
13004                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr1(ndr, NDR_BUFFERS, &r->ctr1));
13005                         break;
13006
13007                         default:
13008                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13009                 }
13010         }
13011         return NDR_ERR_SUCCESS;
13012 }
13013
13014 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostCtr(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostCtr *r)
13015 {
13016         int level;
13017         level = ndr_print_get_switch_value(ndr, r);
13018         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostCtr");
13019         switch (level) {
13020                 case 1:
13021                         ndr_print_drsuapi_QuerySitesByCostCtr1(ndr, "ctr1", &r->ctr1);
13022                 break;
13023
13024                 default:
13025                         ndr_print_bad_level(ndr, name, level);
13026         }
13027 }
13028
13029 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_QuerySitesByCostRequest1 *r)
13030 {
13031         uint32_t cntr_site_to_1;
13032         if (ndr_flags & NDR_SCALARS) {
13033                 NDR_CHECK(ndr_push_align(ndr, 5));
13034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_from));
13035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_req));
13036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to));
13037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
13038                 NDR_CHECK(ndr_push_trailer_align(ndr, 5));
13039         }
13040         if (ndr_flags & NDR_BUFFERS) {
13041                 if (r->site_from) {
13042                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13043                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13044                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_from, CH_UTF16)));
13045                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->site_from, ndr_charset_length(r->site_from, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13046                 }
13047                 if (r->site_to) {
13048                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->num_req));
13049                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13050                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->site_to[cntr_site_to_1]));
13051                         }
13052                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13053                                 if (r->site_to[cntr_site_to_1]) {
13054                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13055                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, 0));
13056                                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, ndr_charset_length(r->site_to[cntr_site_to_1], CH_UTF16)));
13057                                         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));
13058                                 }
13059                         }
13060                 }
13061         }
13062         return NDR_ERR_SUCCESS;
13063 }
13064
13065 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_QuerySitesByCostRequest1 *r)
13066 {
13067         uint32_t _ptr_site_from;
13068         TALLOC_CTX *_mem_save_site_from_0;
13069         uint32_t _ptr_site_to;
13070         uint32_t cntr_site_to_1;
13071         TALLOC_CTX *_mem_save_site_to_0;
13072         TALLOC_CTX *_mem_save_site_to_1;
13073         TALLOC_CTX *_mem_save_site_to_2;
13074         if (ndr_flags & NDR_SCALARS) {
13075                 NDR_CHECK(ndr_pull_align(ndr, 5));
13076                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_from));
13077                 if (_ptr_site_from) {
13078                         NDR_PULL_ALLOC(ndr, r->site_from);
13079                 } else {
13080                         r->site_from = NULL;
13081                 }
13082                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_req));
13083                 if (r->num_req < 1 || r->num_req > 10000) {
13084                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
13085                 }
13086                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13087                 if (_ptr_site_to) {
13088                         NDR_PULL_ALLOC(ndr, r->site_to);
13089                 } else {
13090                         r->site_to = NULL;
13091                 }
13092                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
13093                 NDR_CHECK(ndr_pull_trailer_align(ndr, 5));
13094         }
13095         if (ndr_flags & NDR_BUFFERS) {
13096                 if (r->site_from) {
13097                         _mem_save_site_from_0 = NDR_PULL_GET_MEM_CTX(ndr);
13098                         NDR_PULL_SET_MEM_CTX(ndr, r->site_from, 0);
13099                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_from));
13100                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_from));
13101                         if (ndr_get_array_length(ndr, &r->site_from) > ndr_get_array_size(ndr, &r->site_from)) {
13102                                 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));
13103                         }
13104                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t)));
13105                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->site_from, ndr_get_array_length(ndr, &r->site_from), sizeof(uint16_t), CH_UTF16));
13106                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_from_0, 0);
13107                 }
13108                 if (r->site_to) {
13109                         _mem_save_site_to_0 = NDR_PULL_GET_MEM_CTX(ndr);
13110                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13111                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to));
13112                         NDR_PULL_ALLOC_N(ndr, r->site_to, ndr_get_array_size(ndr, &r->site_to));
13113                         _mem_save_site_to_1 = NDR_PULL_GET_MEM_CTX(ndr);
13114                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to, 0);
13115                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13116                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_site_to));
13117                                 if (_ptr_site_to) {
13118                                         NDR_PULL_ALLOC(ndr, r->site_to[cntr_site_to_1]);
13119                                 } else {
13120                                         r->site_to[cntr_site_to_1] = NULL;
13121                                 }
13122                         }
13123                         for (cntr_site_to_1 = 0; cntr_site_to_1 < r->num_req; cntr_site_to_1++) {
13124                                 if (r->site_to[cntr_site_to_1]) {
13125                                         _mem_save_site_to_2 = NDR_PULL_GET_MEM_CTX(ndr);
13126                                         NDR_PULL_SET_MEM_CTX(ndr, r->site_to[cntr_site_to_1], 0);
13127                                         NDR_CHECK(ndr_pull_array_size(ndr, &r->site_to[cntr_site_to_1]));
13128                                         NDR_CHECK(ndr_pull_array_length(ndr, &r->site_to[cntr_site_to_1]));
13129                                         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])) {
13130                                                 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]));
13131                                         }
13132                                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->site_to[cntr_site_to_1]), sizeof(uint16_t)));
13133                                         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));
13134                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_2, 0);
13135                                 }
13136                         }
13137                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_1, 0);
13138                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_site_to_0, 0);
13139                 }
13140                 if (r->site_to) {
13141                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->site_to, r->num_req));
13142                 }
13143         }
13144         return NDR_ERR_SUCCESS;
13145 }
13146
13147 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_QuerySitesByCostRequest1 *r)
13148 {
13149         uint32_t cntr_site_to_1;
13150         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCostRequest1");
13151         ndr->depth++;
13152         ndr_print_ptr(ndr, "site_from", r->site_from);
13153         ndr->depth++;
13154         if (r->site_from) {
13155                 ndr_print_string(ndr, "site_from", r->site_from);
13156         }
13157         ndr->depth--;
13158         ndr_print_uint32(ndr, "num_req", r->num_req);
13159         ndr_print_ptr(ndr, "site_to", r->site_to);
13160         ndr->depth++;
13161         if (r->site_to) {
13162                 ndr->print(ndr, "%s: ARRAY(%d)", "site_to", (int)r->num_req);
13163                 ndr->depth++;
13164                 for (cntr_site_to_1=0;cntr_site_to_1<r->num_req;cntr_site_to_1++) {
13165                         char *idx_1=NULL;
13166                         if (asprintf(&idx_1, "[%d]", cntr_site_to_1) != -1) {
13167                                 ndr_print_ptr(ndr, "site_to", r->site_to[cntr_site_to_1]);
13168                                 ndr->depth++;
13169                                 if (r->site_to[cntr_site_to_1]) {
13170                                         ndr_print_string(ndr, "site_to", r->site_to[cntr_site_to_1]);
13171                                 }
13172                                 ndr->depth--;
13173                                 free(idx_1);
13174                         }
13175                 }
13176                 ndr->depth--;
13177         }
13178         ndr->depth--;
13179         ndr_print_uint32(ndr, "flags", r->flags);
13180         ndr->depth--;
13181 }
13182
13183 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCostRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_QuerySitesByCostRequest *r)
13184 {
13185         if (ndr_flags & NDR_SCALARS) {
13186                 int level = ndr_push_get_switch_value(ndr, r);
13187                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level));
13188                 NDR_CHECK(ndr_push_union_align(ndr, 5));
13189                 switch (level) {
13190                         case 1: {
13191                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13192                         break; }
13193
13194                         default:
13195                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13196                 }
13197         }
13198         if (ndr_flags & NDR_BUFFERS) {
13199                 int level = ndr_push_get_switch_value(ndr, r);
13200                 switch (level) {
13201                         case 1:
13202                                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13203                         break;
13204
13205                         default:
13206                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13207                 }
13208         }
13209         return NDR_ERR_SUCCESS;
13210 }
13211
13212 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCostRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_QuerySitesByCostRequest *r)
13213 {
13214         int level;
13215         int32_t _level;
13216         level = ndr_pull_get_switch_value(ndr, r);
13217         if (ndr_flags & NDR_SCALARS) {
13218                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level));
13219                 if (_level != level) {
13220                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__);
13221                 }
13222                 NDR_CHECK(ndr_pull_union_align(ndr, 5));
13223                 switch (level) {
13224                         case 1: {
13225                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_SCALARS, &r->req1));
13226                         break; }
13227
13228                         default:
13229                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13230                 }
13231         }
13232         if (ndr_flags & NDR_BUFFERS) {
13233                 switch (level) {
13234                         case 1:
13235                                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest1(ndr, NDR_BUFFERS, &r->req1));
13236                         break;
13237
13238                         default:
13239                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__);
13240                 }
13241         }
13242         return NDR_ERR_SUCCESS;
13243 }
13244
13245 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCostRequest(struct ndr_print *ndr, const char *name, const union drsuapi_QuerySitesByCostRequest *r)
13246 {
13247         int level;
13248         level = ndr_print_get_switch_value(ndr, r);
13249         ndr_print_union(ndr, name, level, "drsuapi_QuerySitesByCostRequest");
13250         switch (level) {
13251                 case 1:
13252                         ndr_print_drsuapi_QuerySitesByCostRequest1(ndr, "req1", &r->req1);
13253                 break;
13254
13255                 default:
13256                         ndr_print_bad_level(ndr, name, level);
13257         }
13258 }
13259
13260 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsBind(struct ndr_push *ndr, int flags, const struct drsuapi_DsBind *r)
13261 {
13262         if (flags & NDR_IN) {
13263                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_guid));
13264                 if (r->in.bind_guid) {
13265                         NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13266                 }
13267                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.bind_info));
13268                 if (r->in.bind_info) {
13269                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13270                 }
13271         }
13272         if (flags & NDR_OUT) {
13273                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.bind_info));
13274                 if (r->out.bind_info) {
13275                         NDR_CHECK(ndr_push_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13276                 }
13277                 if (r->out.bind_handle == NULL) {
13278                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13279                 }
13280                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13281                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13282         }
13283         return NDR_ERR_SUCCESS;
13284 }
13285
13286 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsBind(struct ndr_pull *ndr, int flags, struct drsuapi_DsBind *r)
13287 {
13288         uint32_t _ptr_bind_guid;
13289         uint32_t _ptr_bind_info;
13290         TALLOC_CTX *_mem_save_bind_guid_0;
13291         TALLOC_CTX *_mem_save_bind_info_0;
13292         TALLOC_CTX *_mem_save_bind_handle_0;
13293         if (flags & NDR_IN) {
13294                 ZERO_STRUCT(r->out);
13295
13296                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_guid));
13297                 if (_ptr_bind_guid) {
13298                         NDR_PULL_ALLOC(ndr, r->in.bind_guid);
13299                 } else {
13300                         r->in.bind_guid = NULL;
13301                 }
13302                 if (r->in.bind_guid) {
13303                         _mem_save_bind_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
13304                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_guid, 0);
13305                         NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, r->in.bind_guid));
13306                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_guid_0, 0);
13307                 }
13308                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13309                 if (_ptr_bind_info) {
13310                         NDR_PULL_ALLOC(ndr, r->in.bind_info);
13311                 } else {
13312                         r->in.bind_info = NULL;
13313                 }
13314                 if (r->in.bind_info) {
13315                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13316                         NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_info, 0);
13317                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->in.bind_info));
13318                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13319                 }
13320                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13321                 ZERO_STRUCTP(r->out.bind_handle);
13322         }
13323         if (flags & NDR_OUT) {
13324                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_bind_info));
13325                 if (_ptr_bind_info) {
13326                         NDR_PULL_ALLOC(ndr, r->out.bind_info);
13327                 } else {
13328                         r->out.bind_info = NULL;
13329                 }
13330                 if (r->out.bind_info) {
13331                         _mem_save_bind_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13332                         NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_info, 0);
13333                         NDR_CHECK(ndr_pull_drsuapi_DsBindInfoCtr(ndr, NDR_SCALARS, r->out.bind_info));
13334                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_info_0, 0);
13335                 }
13336                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13337                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13338                 }
13339                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13340                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13341                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13342                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13343                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13344         }
13345         return NDR_ERR_SUCCESS;
13346 }
13347
13348 _PUBLIC_ void ndr_print_drsuapi_DsBind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsBind *r)
13349 {
13350         ndr_print_struct(ndr, name, "drsuapi_DsBind");
13351         ndr->depth++;
13352         if (flags & NDR_SET_VALUES) {
13353                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13354         }
13355         if (flags & NDR_IN) {
13356                 ndr_print_struct(ndr, "in", "drsuapi_DsBind");
13357                 ndr->depth++;
13358                 ndr_print_ptr(ndr, "bind_guid", r->in.bind_guid);
13359                 ndr->depth++;
13360                 if (r->in.bind_guid) {
13361                         ndr_print_GUID(ndr, "bind_guid", r->in.bind_guid);
13362                 }
13363                 ndr->depth--;
13364                 ndr_print_ptr(ndr, "bind_info", r->in.bind_info);
13365                 ndr->depth++;
13366                 if (r->in.bind_info) {
13367                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->in.bind_info);
13368                 }
13369                 ndr->depth--;
13370                 ndr->depth--;
13371         }
13372         if (flags & NDR_OUT) {
13373                 ndr_print_struct(ndr, "out", "drsuapi_DsBind");
13374                 ndr->depth++;
13375                 ndr_print_ptr(ndr, "bind_info", r->out.bind_info);
13376                 ndr->depth++;
13377                 if (r->out.bind_info) {
13378                         ndr_print_drsuapi_DsBindInfoCtr(ndr, "bind_info", r->out.bind_info);
13379                 }
13380                 ndr->depth--;
13381                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13382                 ndr->depth++;
13383                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13384                 ndr->depth--;
13385                 ndr_print_WERROR(ndr, "result", r->out.result);
13386                 ndr->depth--;
13387         }
13388         ndr->depth--;
13389 }
13390
13391 static enum ndr_err_code ndr_push_drsuapi_DsUnbind(struct ndr_push *ndr, int flags, const struct drsuapi_DsUnbind *r)
13392 {
13393         if (flags & NDR_IN) {
13394                 if (r->in.bind_handle == NULL) {
13395                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13396                 }
13397                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13398         }
13399         if (flags & NDR_OUT) {
13400                 if (r->out.bind_handle == NULL) {
13401                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13402                 }
13403                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13404                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13405         }
13406         return NDR_ERR_SUCCESS;
13407 }
13408
13409 static enum ndr_err_code ndr_pull_drsuapi_DsUnbind(struct ndr_pull *ndr, int flags, struct drsuapi_DsUnbind *r)
13410 {
13411         TALLOC_CTX *_mem_save_bind_handle_0;
13412         if (flags & NDR_IN) {
13413                 ZERO_STRUCT(r->out);
13414
13415                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13416                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13417                 }
13418                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13419                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13420                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13421                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13422                 NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13423                 *r->out.bind_handle = *r->in.bind_handle;
13424         }
13425         if (flags & NDR_OUT) {
13426                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13427                         NDR_PULL_ALLOC(ndr, r->out.bind_handle);
13428                 }
13429                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13430                 NDR_PULL_SET_MEM_CTX(ndr, r->out.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13431                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.bind_handle));
13432                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13433                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13434         }
13435         return NDR_ERR_SUCCESS;
13436 }
13437
13438 _PUBLIC_ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsUnbind *r)
13439 {
13440         ndr_print_struct(ndr, name, "drsuapi_DsUnbind");
13441         ndr->depth++;
13442         if (flags & NDR_SET_VALUES) {
13443                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13444         }
13445         if (flags & NDR_IN) {
13446                 ndr_print_struct(ndr, "in", "drsuapi_DsUnbind");
13447                 ndr->depth++;
13448                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13449                 ndr->depth++;
13450                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13451                 ndr->depth--;
13452                 ndr->depth--;
13453         }
13454         if (flags & NDR_OUT) {
13455                 ndr_print_struct(ndr, "out", "drsuapi_DsUnbind");
13456                 ndr->depth++;
13457                 ndr_print_ptr(ndr, "bind_handle", r->out.bind_handle);
13458                 ndr->depth++;
13459                 ndr_print_policy_handle(ndr, "bind_handle", r->out.bind_handle);
13460                 ndr->depth--;
13461                 ndr_print_WERROR(ndr, "result", r->out.result);
13462                 ndr->depth--;
13463         }
13464         ndr->depth--;
13465 }
13466
13467 static enum ndr_err_code ndr_push_drsuapi_DsReplicaSync(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaSync *r)
13468 {
13469         if (flags & NDR_IN) {
13470                 if (r->in.bind_handle == NULL) {
13471                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13472                 }
13473                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13474                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13475                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13476                 NDR_CHECK(ndr_push_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13477         }
13478         if (flags & NDR_OUT) {
13479                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13480         }
13481         return NDR_ERR_SUCCESS;
13482 }
13483
13484 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaSync(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaSync *r)
13485 {
13486         TALLOC_CTX *_mem_save_bind_handle_0;
13487         if (flags & NDR_IN) {
13488                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13489                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13490                 }
13491                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13492                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13493                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13494                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13495                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13496                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13497                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaSyncRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13498         }
13499         if (flags & NDR_OUT) {
13500                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13501         }
13502         return NDR_ERR_SUCCESS;
13503 }
13504
13505 _PUBLIC_ void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r)
13506 {
13507         ndr_print_struct(ndr, name, "drsuapi_DsReplicaSync");
13508         ndr->depth++;
13509         if (flags & NDR_SET_VALUES) {
13510                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13511         }
13512         if (flags & NDR_IN) {
13513                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaSync");
13514                 ndr->depth++;
13515                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13516                 ndr->depth++;
13517                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13518                 ndr->depth--;
13519                 ndr_print_int32(ndr, "level", r->in.level);
13520                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13521                 ndr_print_drsuapi_DsReplicaSyncRequest(ndr, "req", &r->in.req);
13522                 ndr->depth--;
13523         }
13524         if (flags & NDR_OUT) {
13525                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaSync");
13526                 ndr->depth++;
13527                 ndr_print_WERROR(ndr, "result", r->out.result);
13528                 ndr->depth--;
13529         }
13530         ndr->depth--;
13531 }
13532
13533 static enum ndr_err_code ndr_push_drsuapi_DsGetNCChanges(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNCChanges *r)
13534 {
13535         if (flags & NDR_IN) {
13536                 if (r->in.bind_handle == NULL) {
13537                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13538                 }
13539                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13540                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13541                 if (r->in.req == NULL) {
13542                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13543                 }
13544                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13545                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13546         }
13547         if (flags & NDR_OUT) {
13548                 if (r->out.level_out == NULL) {
13549                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13550                 }
13551                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13552                 if (r->out.ctr == NULL) {
13553                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13554                 }
13555                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13556                 NDR_CHECK(ndr_push_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13557                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13558         }
13559         return NDR_ERR_SUCCESS;
13560 }
13561
13562 static enum ndr_err_code ndr_pull_drsuapi_DsGetNCChanges(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNCChanges *r)
13563 {
13564         TALLOC_CTX *_mem_save_bind_handle_0;
13565         TALLOC_CTX *_mem_save_req_0;
13566         TALLOC_CTX *_mem_save_level_out_0;
13567         TALLOC_CTX *_mem_save_ctr_0;
13568         if (flags & NDR_IN) {
13569                 ZERO_STRUCT(r->out);
13570
13571                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13572                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13573                 }
13574                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13575                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13576                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13577                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13578                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13579                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13580                         NDR_PULL_ALLOC(ndr, r->in.req);
13581                 }
13582                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
13583                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
13584                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
13585                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13586                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
13587                 NDR_PULL_ALLOC(ndr, r->out.level_out);
13588                 ZERO_STRUCTP(r->out.level_out);
13589                 NDR_PULL_ALLOC(ndr, r->out.ctr);
13590                 ZERO_STRUCTP(r->out.ctr);
13591         }
13592         if (flags & NDR_OUT) {
13593                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13594                         NDR_PULL_ALLOC(ndr, r->out.level_out);
13595                 }
13596                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
13597                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
13598                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
13599                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
13600                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13601                         NDR_PULL_ALLOC(ndr, r->out.ctr);
13602                 }
13603                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
13604                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
13605                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13606                 NDR_CHECK(ndr_pull_drsuapi_DsGetNCChangesCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13607                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
13608                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13609         }
13610         return NDR_ERR_SUCCESS;
13611 }
13612
13613 _PUBLIC_ void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r)
13614 {
13615         ndr_print_struct(ndr, name, "drsuapi_DsGetNCChanges");
13616         ndr->depth++;
13617         if (flags & NDR_SET_VALUES) {
13618                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13619         }
13620         if (flags & NDR_IN) {
13621                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNCChanges");
13622                 ndr->depth++;
13623                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13624                 ndr->depth++;
13625                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13626                 ndr->depth--;
13627                 ndr_print_int32(ndr, "level", r->in.level);
13628                 ndr_print_ptr(ndr, "req", r->in.req);
13629                 ndr->depth++;
13630                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
13631                 ndr_print_drsuapi_DsGetNCChangesRequest(ndr, "req", r->in.req);
13632                 ndr->depth--;
13633                 ndr->depth--;
13634         }
13635         if (flags & NDR_OUT) {
13636                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNCChanges");
13637                 ndr->depth++;
13638                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
13639                 ndr->depth++;
13640                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
13641                 ndr->depth--;
13642                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
13643                 ndr->depth++;
13644                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
13645                 ndr_print_drsuapi_DsGetNCChangesCtr(ndr, "ctr", r->out.ctr);
13646                 ndr->depth--;
13647                 ndr_print_WERROR(ndr, "result", r->out.result);
13648                 ndr->depth--;
13649         }
13650         ndr->depth--;
13651 }
13652
13653 static enum ndr_err_code ndr_push_drsuapi_DsReplicaUpdateRefs(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13654 {
13655         if (flags & NDR_IN) {
13656                 if (r->in.bind_handle == NULL) {
13657                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13658                 }
13659                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13660                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13661                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13662                 NDR_CHECK(ndr_push_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13663         }
13664         if (flags & NDR_OUT) {
13665                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13666         }
13667         return NDR_ERR_SUCCESS;
13668 }
13669
13670 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaUpdateRefs(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaUpdateRefs *r)
13671 {
13672         TALLOC_CTX *_mem_save_bind_handle_0;
13673         if (flags & NDR_IN) {
13674                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13675                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13676                 }
13677                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13678                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13679                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13680                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13681                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13682                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13683                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaUpdateRefsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13684         }
13685         if (flags & NDR_OUT) {
13686                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13687         }
13688         return NDR_ERR_SUCCESS;
13689 }
13690
13691 _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r)
13692 {
13693         ndr_print_struct(ndr, name, "drsuapi_DsReplicaUpdateRefs");
13694         ndr->depth++;
13695         if (flags & NDR_SET_VALUES) {
13696                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13697         }
13698         if (flags & NDR_IN) {
13699                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaUpdateRefs");
13700                 ndr->depth++;
13701                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13702                 ndr->depth++;
13703                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13704                 ndr->depth--;
13705                 ndr_print_int32(ndr, "level", r->in.level);
13706                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13707                 ndr_print_drsuapi_DsReplicaUpdateRefsRequest(ndr, "req", &r->in.req);
13708                 ndr->depth--;
13709         }
13710         if (flags & NDR_OUT) {
13711                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaUpdateRefs");
13712                 ndr->depth++;
13713                 ndr_print_WERROR(ndr, "result", r->out.result);
13714                 ndr->depth--;
13715         }
13716         ndr->depth--;
13717 }
13718
13719 static enum ndr_err_code ndr_push_drsuapi_DsReplicaAdd(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaAdd *r)
13720 {
13721         if (flags & NDR_IN) {
13722                 if (r->in.bind_handle == NULL) {
13723                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13724                 }
13725                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13726                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13727                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13728                 NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13729         }
13730         if (flags & NDR_OUT) {
13731                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13732         }
13733         return NDR_ERR_SUCCESS;
13734 }
13735
13736 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAdd(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaAdd *r)
13737 {
13738         TALLOC_CTX *_mem_save_bind_handle_0;
13739         if (flags & NDR_IN) {
13740                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13741                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13742                 }
13743                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13744                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13745                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13747                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13748                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13749                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13750         }
13751         if (flags & NDR_OUT) {
13752                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13753         }
13754         return NDR_ERR_SUCCESS;
13755 }
13756
13757 _PUBLIC_ void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r)
13758 {
13759         ndr_print_struct(ndr, name, "drsuapi_DsReplicaAdd");
13760         ndr->depth++;
13761         if (flags & NDR_SET_VALUES) {
13762                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13763         }
13764         if (flags & NDR_IN) {
13765                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaAdd");
13766                 ndr->depth++;
13767                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13768                 ndr->depth++;
13769                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13770                 ndr->depth--;
13771                 ndr_print_int32(ndr, "level", r->in.level);
13772                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13773                 ndr_print_drsuapi_DsReplicaAddRequest(ndr, "req", &r->in.req);
13774                 ndr->depth--;
13775         }
13776         if (flags & NDR_OUT) {
13777                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaAdd");
13778                 ndr->depth++;
13779                 ndr_print_WERROR(ndr, "result", r->out.result);
13780                 ndr->depth--;
13781         }
13782         ndr->depth--;
13783 }
13784
13785 static enum ndr_err_code ndr_push_drsuapi_DsReplicaDel(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaDel *r)
13786 {
13787         if (flags & NDR_IN) {
13788                 if (r->in.bind_handle == NULL) {
13789                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13790                 }
13791                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13792                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13793                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13794                 NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13795         }
13796         if (flags & NDR_OUT) {
13797                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13798         }
13799         return NDR_ERR_SUCCESS;
13800 }
13801
13802 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDel(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaDel *r)
13803 {
13804         TALLOC_CTX *_mem_save_bind_handle_0;
13805         if (flags & NDR_IN) {
13806                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13807                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13808                 }
13809                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13810                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13811                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13812                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13813                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13814                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13815                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13816         }
13817         if (flags & NDR_OUT) {
13818                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13819         }
13820         return NDR_ERR_SUCCESS;
13821 }
13822
13823 _PUBLIC_ void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r)
13824 {
13825         ndr_print_struct(ndr, name, "drsuapi_DsReplicaDel");
13826         ndr->depth++;
13827         if (flags & NDR_SET_VALUES) {
13828                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13829         }
13830         if (flags & NDR_IN) {
13831                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaDel");
13832                 ndr->depth++;
13833                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13834                 ndr->depth++;
13835                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13836                 ndr->depth--;
13837                 ndr_print_int32(ndr, "level", r->in.level);
13838                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13839                 ndr_print_drsuapi_DsReplicaDelRequest(ndr, "req", &r->in.req);
13840                 ndr->depth--;
13841         }
13842         if (flags & NDR_OUT) {
13843                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaDel");
13844                 ndr->depth++;
13845                 ndr_print_WERROR(ndr, "result", r->out.result);
13846                 ndr->depth--;
13847         }
13848         ndr->depth--;
13849 }
13850
13851 static enum ndr_err_code ndr_push_drsuapi_DsReplicaMod(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaMod *r)
13852 {
13853         if (flags & NDR_IN) {
13854                 if (r->in.bind_handle == NULL) {
13855                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13856                 }
13857                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13858                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13859                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level));
13860                 NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13861         }
13862         if (flags & NDR_OUT) {
13863                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13864         }
13865         return NDR_ERR_SUCCESS;
13866 }
13867
13868 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMod(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaMod *r)
13869 {
13870         TALLOC_CTX *_mem_save_bind_handle_0;
13871         if (flags & NDR_IN) {
13872                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13873                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13874                 }
13875                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13876                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
13877                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13878                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
13879                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
13880                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level));
13881                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req));
13882         }
13883         if (flags & NDR_OUT) {
13884                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13885         }
13886         return NDR_ERR_SUCCESS;
13887 }
13888
13889 _PUBLIC_ void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r)
13890 {
13891         ndr_print_struct(ndr, name, "drsuapi_DsReplicaMod");
13892         ndr->depth++;
13893         if (flags & NDR_SET_VALUES) {
13894                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13895         }
13896         if (flags & NDR_IN) {
13897                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaMod");
13898                 ndr->depth++;
13899                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
13900                 ndr->depth++;
13901                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
13902                 ndr->depth--;
13903                 ndr_print_int32(ndr, "level", r->in.level);
13904                 ndr_print_set_switch_value(ndr, &r->in.req, r->in.level);
13905                 ndr_print_drsuapi_DsReplicaModRequest(ndr, "req", &r->in.req);
13906                 ndr->depth--;
13907         }
13908         if (flags & NDR_OUT) {
13909                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaMod");
13910                 ndr->depth++;
13911                 ndr_print_WERROR(ndr, "result", r->out.result);
13912                 ndr->depth--;
13913         }
13914         ndr->depth--;
13915 }
13916
13917 static enum ndr_err_code ndr_push_DRSUAPI_VERIFY_NAMES(struct ndr_push *ndr, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13918 {
13919         if (flags & NDR_IN) {
13920         }
13921         if (flags & NDR_OUT) {
13922                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13923         }
13924         return NDR_ERR_SUCCESS;
13925 }
13926
13927 static enum ndr_err_code ndr_pull_DRSUAPI_VERIFY_NAMES(struct ndr_pull *ndr, int flags, struct DRSUAPI_VERIFY_NAMES *r)
13928 {
13929         if (flags & NDR_IN) {
13930         }
13931         if (flags & NDR_OUT) {
13932                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13933         }
13934         return NDR_ERR_SUCCESS;
13935 }
13936
13937 _PUBLIC_ void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r)
13938 {
13939         ndr_print_struct(ndr, name, "DRSUAPI_VERIFY_NAMES");
13940         ndr->depth++;
13941         if (flags & NDR_SET_VALUES) {
13942                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13943         }
13944         if (flags & NDR_IN) {
13945                 ndr_print_struct(ndr, "in", "DRSUAPI_VERIFY_NAMES");
13946                 ndr->depth++;
13947                 ndr->depth--;
13948         }
13949         if (flags & NDR_OUT) {
13950                 ndr_print_struct(ndr, "out", "DRSUAPI_VERIFY_NAMES");
13951                 ndr->depth++;
13952                 ndr_print_WERROR(ndr, "result", r->out.result);
13953                 ndr->depth--;
13954         }
13955         ndr->depth--;
13956 }
13957
13958 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships *r)
13959 {
13960         if (flags & NDR_IN) {
13961                 if (r->in.bind_handle == NULL) {
13962                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13963                 }
13964                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
13965                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
13966                 if (r->in.req == NULL) {
13967                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13968                 }
13969                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
13970                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
13971         }
13972         if (flags & NDR_OUT) {
13973                 if (r->out.level_out == NULL) {
13974                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13975                 }
13976                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
13977                 if (r->out.ctr == NULL) {
13978                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13979                 }
13980                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
13981                 NDR_CHECK(ndr_push_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
13982                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13983         }
13984         return NDR_ERR_SUCCESS;
13985 }
13986
13987 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships *r)
13988 {
13989         TALLOC_CTX *_mem_save_bind_handle_0;
13990         TALLOC_CTX *_mem_save_req_0;
13991         TALLOC_CTX *_mem_save_level_out_0;
13992         TALLOC_CTX *_mem_save_ctr_0;
13993         if (flags & NDR_IN) {
13994                 ZERO_STRUCT(r->out);
13995
13996                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13997                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
13998                 }
13999                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14000                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14001                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14002                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14003                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14004                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14005                         NDR_PULL_ALLOC(ndr, r->in.req);
14006                 }
14007                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14008                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14009                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14010                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14011                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14012                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14013                 ZERO_STRUCTP(r->out.level_out);
14014                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14015                 ZERO_STRUCTP(r->out.ctr);
14016         }
14017         if (flags & NDR_OUT) {
14018                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14019                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14020                 }
14021                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14022                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14023                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14024                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14025                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14026                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14027                 }
14028                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14029                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14030                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14031                 NDR_CHECK(ndr_pull_drsuapi_DsGetMembershipsCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14032                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14033                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14034         }
14035         return NDR_ERR_SUCCESS;
14036 }
14037
14038 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r)
14039 {
14040         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships");
14041         ndr->depth++;
14042         if (flags & NDR_SET_VALUES) {
14043                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14044         }
14045         if (flags & NDR_IN) {
14046                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships");
14047                 ndr->depth++;
14048                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14049                 ndr->depth++;
14050                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14051                 ndr->depth--;
14052                 ndr_print_int32(ndr, "level", r->in.level);
14053                 ndr_print_ptr(ndr, "req", r->in.req);
14054                 ndr->depth++;
14055                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14056                 ndr_print_drsuapi_DsGetMembershipsRequest(ndr, "req", r->in.req);
14057                 ndr->depth--;
14058                 ndr->depth--;
14059         }
14060         if (flags & NDR_OUT) {
14061                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships");
14062                 ndr->depth++;
14063                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14064                 ndr->depth++;
14065                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14066                 ndr->depth--;
14067                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14068                 ndr->depth++;
14069                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14070                 ndr_print_drsuapi_DsGetMembershipsCtr(ndr, "ctr", r->out.ctr);
14071                 ndr->depth--;
14072                 ndr_print_WERROR(ndr, "result", r->out.result);
14073                 ndr->depth--;
14074         }
14075         ndr->depth--;
14076 }
14077
14078 static enum ndr_err_code ndr_push_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_push *ndr, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14079 {
14080         if (flags & NDR_IN) {
14081         }
14082         if (flags & NDR_OUT) {
14083                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14084         }
14085         return NDR_ERR_SUCCESS;
14086 }
14087
14088 static enum ndr_err_code ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_pull *ndr, int flags, struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14089 {
14090         if (flags & NDR_IN) {
14091         }
14092         if (flags & NDR_OUT) {
14093                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14094         }
14095         return NDR_ERR_SUCCESS;
14096 }
14097
14098 _PUBLIC_ void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r)
14099 {
14100         ndr_print_struct(ndr, name, "DRSUAPI_INTER_DOMAIN_MOVE");
14101         ndr->depth++;
14102         if (flags & NDR_SET_VALUES) {
14103                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14104         }
14105         if (flags & NDR_IN) {
14106                 ndr_print_struct(ndr, "in", "DRSUAPI_INTER_DOMAIN_MOVE");
14107                 ndr->depth++;
14108                 ndr->depth--;
14109         }
14110         if (flags & NDR_OUT) {
14111                 ndr_print_struct(ndr, "out", "DRSUAPI_INTER_DOMAIN_MOVE");
14112                 ndr->depth++;
14113                 ndr_print_WERROR(ndr, "result", r->out.result);
14114                 ndr->depth--;
14115         }
14116         ndr->depth--;
14117 }
14118
14119 static enum ndr_err_code ndr_push_drsuapi_DsGetNT4ChangeLog(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14120 {
14121         if (flags & NDR_IN) {
14122                 if (r->in.bind_handle == NULL) {
14123                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14124                 }
14125                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14126                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14127                 if (r->in.req == NULL) {
14128                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14129                 }
14130                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14131                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14132         }
14133         if (flags & NDR_OUT) {
14134                 if (r->out.level_out == NULL) {
14135                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14136                 }
14137                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.level_out));
14138                 if (r->out.info == NULL) {
14139                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14140                 }
14141                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.level_out));
14142                 NDR_CHECK(ndr_push_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14143                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14144         }
14145         return NDR_ERR_SUCCESS;
14146 }
14147
14148 static enum ndr_err_code ndr_pull_drsuapi_DsGetNT4ChangeLog(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetNT4ChangeLog *r)
14149 {
14150         TALLOC_CTX *_mem_save_bind_handle_0;
14151         TALLOC_CTX *_mem_save_req_0;
14152         TALLOC_CTX *_mem_save_level_out_0;
14153         TALLOC_CTX *_mem_save_info_0;
14154         if (flags & NDR_IN) {
14155                 ZERO_STRUCT(r->out);
14156
14157                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14158                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14159                 }
14160                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14161                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14162                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14163                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14165                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14166                         NDR_PULL_ALLOC(ndr, r->in.req);
14167                 }
14168                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14169                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14170                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14171                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14172                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14173                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14174                 ZERO_STRUCTP(r->out.level_out);
14175                 NDR_PULL_ALLOC(ndr, r->out.info);
14176                 ZERO_STRUCTP(r->out.info);
14177         }
14178         if (flags & NDR_OUT) {
14179                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14180                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14181                 }
14182                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14183                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.level_out));
14185                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14186                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14187                         NDR_PULL_ALLOC(ndr, r->out.info);
14188                 }
14189                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14190                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14191                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.level_out));
14192                 NDR_CHECK(ndr_pull_drsuapi_DsGetNT4ChangeLogInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14193                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14194                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14195         }
14196         return NDR_ERR_SUCCESS;
14197 }
14198
14199 _PUBLIC_ void ndr_print_drsuapi_DsGetNT4ChangeLog(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNT4ChangeLog *r)
14200 {
14201         ndr_print_struct(ndr, name, "drsuapi_DsGetNT4ChangeLog");
14202         ndr->depth++;
14203         if (flags & NDR_SET_VALUES) {
14204                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14205         }
14206         if (flags & NDR_IN) {
14207                 ndr_print_struct(ndr, "in", "drsuapi_DsGetNT4ChangeLog");
14208                 ndr->depth++;
14209                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14210                 ndr->depth++;
14211                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14212                 ndr->depth--;
14213                 ndr_print_uint32(ndr, "level", r->in.level);
14214                 ndr_print_ptr(ndr, "req", r->in.req);
14215                 ndr->depth++;
14216                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14217                 ndr_print_drsuapi_DsGetNT4ChangeLogRequest(ndr, "req", r->in.req);
14218                 ndr->depth--;
14219                 ndr->depth--;
14220         }
14221         if (flags & NDR_OUT) {
14222                 ndr_print_struct(ndr, "out", "drsuapi_DsGetNT4ChangeLog");
14223                 ndr->depth++;
14224                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14225                 ndr->depth++;
14226                 ndr_print_uint32(ndr, "level_out", *r->out.level_out);
14227                 ndr->depth--;
14228                 ndr_print_ptr(ndr, "info", r->out.info);
14229                 ndr->depth++;
14230                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.level_out);
14231                 ndr_print_drsuapi_DsGetNT4ChangeLogInfo(ndr, "info", r->out.info);
14232                 ndr->depth--;
14233                 ndr_print_WERROR(ndr, "result", r->out.result);
14234                 ndr->depth--;
14235         }
14236         ndr->depth--;
14237 }
14238
14239 static enum ndr_err_code ndr_push_drsuapi_DsCrackNames(struct ndr_push *ndr, int flags, const struct drsuapi_DsCrackNames *r)
14240 {
14241         if (flags & NDR_IN) {
14242                 if (r->in.bind_handle == NULL) {
14243                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14244                 }
14245                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14246                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14247                 if (r->in.req == NULL) {
14248                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14249                 }
14250                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14251                 NDR_CHECK(ndr_push_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14252         }
14253         if (flags & NDR_OUT) {
14254                 if (r->out.level_out == NULL) {
14255                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14256                 }
14257                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14258                 if (r->out.ctr == NULL) {
14259                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14260                 }
14261                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14262                 NDR_CHECK(ndr_push_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14263                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14264         }
14265         return NDR_ERR_SUCCESS;
14266 }
14267
14268 static enum ndr_err_code ndr_pull_drsuapi_DsCrackNames(struct ndr_pull *ndr, int flags, struct drsuapi_DsCrackNames *r)
14269 {
14270         TALLOC_CTX *_mem_save_bind_handle_0;
14271         TALLOC_CTX *_mem_save_req_0;
14272         TALLOC_CTX *_mem_save_level_out_0;
14273         TALLOC_CTX *_mem_save_ctr_0;
14274         if (flags & NDR_IN) {
14275                 ZERO_STRUCT(r->out);
14276
14277                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14278                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14279                 }
14280                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14281                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14282                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14283                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14284                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14285                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14286                         NDR_PULL_ALLOC(ndr, r->in.req);
14287                 }
14288                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14289                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14290                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14291                 NDR_CHECK(ndr_pull_drsuapi_DsNameRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14292                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14293                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14294                 ZERO_STRUCTP(r->out.level_out);
14295                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14296                 ZERO_STRUCTP(r->out.ctr);
14297         }
14298         if (flags & NDR_OUT) {
14299                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14300                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14301                 }
14302                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14303                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14304                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14305                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14306                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14307                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14308                 }
14309                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14310                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14311                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14312                 NDR_CHECK(ndr_pull_drsuapi_DsNameCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14313                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14314                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14315         }
14316         return NDR_ERR_SUCCESS;
14317 }
14318
14319 _PUBLIC_ void ndr_print_drsuapi_DsCrackNames(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsCrackNames *r)
14320 {
14321         ndr_print_struct(ndr, name, "drsuapi_DsCrackNames");
14322         ndr->depth++;
14323         if (flags & NDR_SET_VALUES) {
14324                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14325         }
14326         if (flags & NDR_IN) {
14327                 ndr_print_struct(ndr, "in", "drsuapi_DsCrackNames");
14328                 ndr->depth++;
14329                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14330                 ndr->depth++;
14331                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14332                 ndr->depth--;
14333                 ndr_print_int32(ndr, "level", r->in.level);
14334                 ndr_print_ptr(ndr, "req", r->in.req);
14335                 ndr->depth++;
14336                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14337                 ndr_print_drsuapi_DsNameRequest(ndr, "req", r->in.req);
14338                 ndr->depth--;
14339                 ndr->depth--;
14340         }
14341         if (flags & NDR_OUT) {
14342                 ndr_print_struct(ndr, "out", "drsuapi_DsCrackNames");
14343                 ndr->depth++;
14344                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14345                 ndr->depth++;
14346                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14347                 ndr->depth--;
14348                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14349                 ndr->depth++;
14350                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14351                 ndr_print_drsuapi_DsNameCtr(ndr, "ctr", r->out.ctr);
14352                 ndr->depth--;
14353                 ndr_print_WERROR(ndr, "result", r->out.result);
14354                 ndr->depth--;
14355         }
14356         ndr->depth--;
14357 }
14358
14359 static enum ndr_err_code ndr_push_drsuapi_DsWriteAccountSpn(struct ndr_push *ndr, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14360 {
14361         if (flags & NDR_IN) {
14362                 if (r->in.bind_handle == NULL) {
14363                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14364                 }
14365                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14366                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14367                 if (r->in.req == NULL) {
14368                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14369                 }
14370                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14371                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14372         }
14373         if (flags & NDR_OUT) {
14374                 if (r->out.level_out == NULL) {
14375                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14376                 }
14377                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14378                 if (r->out.res == NULL) {
14379                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14380                 }
14381                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14382                 NDR_CHECK(ndr_push_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14383                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14384         }
14385         return NDR_ERR_SUCCESS;
14386 }
14387
14388 static enum ndr_err_code ndr_pull_drsuapi_DsWriteAccountSpn(struct ndr_pull *ndr, int flags, struct drsuapi_DsWriteAccountSpn *r)
14389 {
14390         TALLOC_CTX *_mem_save_bind_handle_0;
14391         TALLOC_CTX *_mem_save_req_0;
14392         TALLOC_CTX *_mem_save_level_out_0;
14393         TALLOC_CTX *_mem_save_res_0;
14394         if (flags & NDR_IN) {
14395                 ZERO_STRUCT(r->out);
14396
14397                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14398                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14399                 }
14400                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14401                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14402                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14403                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14404                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14405                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14406                         NDR_PULL_ALLOC(ndr, r->in.req);
14407                 }
14408                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14409                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14410                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14411                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14412                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14413                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14414                 ZERO_STRUCTP(r->out.level_out);
14415                 NDR_PULL_ALLOC(ndr, r->out.res);
14416                 ZERO_STRUCTP(r->out.res);
14417         }
14418         if (flags & NDR_OUT) {
14419                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14420                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14421                 }
14422                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14423                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14424                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14425                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14426                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14427                         NDR_PULL_ALLOC(ndr, r->out.res);
14428                 }
14429                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14430                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14431                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14432                 NDR_CHECK(ndr_pull_drsuapi_DsWriteAccountSpnResult(ndr, NDR_SCALARS, r->out.res));
14433                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14434                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14435         }
14436         return NDR_ERR_SUCCESS;
14437 }
14438
14439 _PUBLIC_ void ndr_print_drsuapi_DsWriteAccountSpn(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsWriteAccountSpn *r)
14440 {
14441         ndr_print_struct(ndr, name, "drsuapi_DsWriteAccountSpn");
14442         ndr->depth++;
14443         if (flags & NDR_SET_VALUES) {
14444                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14445         }
14446         if (flags & NDR_IN) {
14447                 ndr_print_struct(ndr, "in", "drsuapi_DsWriteAccountSpn");
14448                 ndr->depth++;
14449                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14450                 ndr->depth++;
14451                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14452                 ndr->depth--;
14453                 ndr_print_int32(ndr, "level", r->in.level);
14454                 ndr_print_ptr(ndr, "req", r->in.req);
14455                 ndr->depth++;
14456                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14457                 ndr_print_drsuapi_DsWriteAccountSpnRequest(ndr, "req", r->in.req);
14458                 ndr->depth--;
14459                 ndr->depth--;
14460         }
14461         if (flags & NDR_OUT) {
14462                 ndr_print_struct(ndr, "out", "drsuapi_DsWriteAccountSpn");
14463                 ndr->depth++;
14464                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14465                 ndr->depth++;
14466                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14467                 ndr->depth--;
14468                 ndr_print_ptr(ndr, "res", r->out.res);
14469                 ndr->depth++;
14470                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14471                 ndr_print_drsuapi_DsWriteAccountSpnResult(ndr, "res", r->out.res);
14472                 ndr->depth--;
14473                 ndr_print_WERROR(ndr, "result", r->out.result);
14474                 ndr->depth--;
14475         }
14476         ndr->depth--;
14477 }
14478
14479 static enum ndr_err_code ndr_push_drsuapi_DsRemoveDSServer(struct ndr_push *ndr, int flags, const struct drsuapi_DsRemoveDSServer *r)
14480 {
14481         if (flags & NDR_IN) {
14482                 if (r->in.bind_handle == NULL) {
14483                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14484                 }
14485                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14486                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14487                 if (r->in.req == NULL) {
14488                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14489                 }
14490                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14491                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14492         }
14493         if (flags & NDR_OUT) {
14494                 if (r->out.level_out == NULL) {
14495                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14496                 }
14497                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14498                 if (r->out.res == NULL) {
14499                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14500                 }
14501                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.res, *r->out.level_out));
14502                 NDR_CHECK(ndr_push_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14503                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14504         }
14505         return NDR_ERR_SUCCESS;
14506 }
14507
14508 static enum ndr_err_code ndr_pull_drsuapi_DsRemoveDSServer(struct ndr_pull *ndr, int flags, struct drsuapi_DsRemoveDSServer *r)
14509 {
14510         TALLOC_CTX *_mem_save_bind_handle_0;
14511         TALLOC_CTX *_mem_save_req_0;
14512         TALLOC_CTX *_mem_save_level_out_0;
14513         TALLOC_CTX *_mem_save_res_0;
14514         if (flags & NDR_IN) {
14515                 ZERO_STRUCT(r->out);
14516
14517                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14518                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14519                 }
14520                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14521                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14522                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14523                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14524                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14525                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14526                         NDR_PULL_ALLOC(ndr, r->in.req);
14527                 }
14528                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14529                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14530                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14531                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14532                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14533                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14534                 ZERO_STRUCTP(r->out.level_out);
14535                 NDR_PULL_ALLOC(ndr, r->out.res);
14536                 ZERO_STRUCTP(r->out.res);
14537         }
14538         if (flags & NDR_OUT) {
14539                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14540                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14541                 }
14542                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14543                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14544                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14545                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14546                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14547                         NDR_PULL_ALLOC(ndr, r->out.res);
14548                 }
14549                 _mem_save_res_0 = NDR_PULL_GET_MEM_CTX(ndr);
14550                 NDR_PULL_SET_MEM_CTX(ndr, r->out.res, LIBNDR_FLAG_REF_ALLOC);
14551                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.res, *r->out.level_out));
14552                 NDR_CHECK(ndr_pull_drsuapi_DsRemoveDSServerResult(ndr, NDR_SCALARS, r->out.res));
14553                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_res_0, LIBNDR_FLAG_REF_ALLOC);
14554                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14555         }
14556         return NDR_ERR_SUCCESS;
14557 }
14558
14559 _PUBLIC_ void ndr_print_drsuapi_DsRemoveDSServer(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsRemoveDSServer *r)
14560 {
14561         ndr_print_struct(ndr, name, "drsuapi_DsRemoveDSServer");
14562         ndr->depth++;
14563         if (flags & NDR_SET_VALUES) {
14564                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14565         }
14566         if (flags & NDR_IN) {
14567                 ndr_print_struct(ndr, "in", "drsuapi_DsRemoveDSServer");
14568                 ndr->depth++;
14569                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14570                 ndr->depth++;
14571                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14572                 ndr->depth--;
14573                 ndr_print_int32(ndr, "level", r->in.level);
14574                 ndr_print_ptr(ndr, "req", r->in.req);
14575                 ndr->depth++;
14576                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14577                 ndr_print_drsuapi_DsRemoveDSServerRequest(ndr, "req", r->in.req);
14578                 ndr->depth--;
14579                 ndr->depth--;
14580         }
14581         if (flags & NDR_OUT) {
14582                 ndr_print_struct(ndr, "out", "drsuapi_DsRemoveDSServer");
14583                 ndr->depth++;
14584                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14585                 ndr->depth++;
14586                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14587                 ndr->depth--;
14588                 ndr_print_ptr(ndr, "res", r->out.res);
14589                 ndr->depth++;
14590                 ndr_print_set_switch_value(ndr, r->out.res, *r->out.level_out);
14591                 ndr_print_drsuapi_DsRemoveDSServerResult(ndr, "res", r->out.res);
14592                 ndr->depth--;
14593                 ndr_print_WERROR(ndr, "result", r->out.result);
14594                 ndr->depth--;
14595         }
14596         ndr->depth--;
14597 }
14598
14599 static enum ndr_err_code ndr_push_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_push *ndr, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14600 {
14601         if (flags & NDR_IN) {
14602         }
14603         if (flags & NDR_OUT) {
14604                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14605         }
14606         return NDR_ERR_SUCCESS;
14607 }
14608
14609 static enum ndr_err_code ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_pull *ndr, int flags, struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14610 {
14611         if (flags & NDR_IN) {
14612         }
14613         if (flags & NDR_OUT) {
14614                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14615         }
14616         return NDR_ERR_SUCCESS;
14617 }
14618
14619 _PUBLIC_ void ndr_print_DRSUAPI_REMOVE_DS_DOMAIN(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REMOVE_DS_DOMAIN *r)
14620 {
14621         ndr_print_struct(ndr, name, "DRSUAPI_REMOVE_DS_DOMAIN");
14622         ndr->depth++;
14623         if (flags & NDR_SET_VALUES) {
14624                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14625         }
14626         if (flags & NDR_IN) {
14627                 ndr_print_struct(ndr, "in", "DRSUAPI_REMOVE_DS_DOMAIN");
14628                 ndr->depth++;
14629                 ndr->depth--;
14630         }
14631         if (flags & NDR_OUT) {
14632                 ndr_print_struct(ndr, "out", "DRSUAPI_REMOVE_DS_DOMAIN");
14633                 ndr->depth++;
14634                 ndr_print_WERROR(ndr, "result", r->out.result);
14635                 ndr->depth--;
14636         }
14637         ndr->depth--;
14638 }
14639
14640 static enum ndr_err_code ndr_push_drsuapi_DsGetDomainControllerInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14641 {
14642         if (flags & NDR_IN) {
14643                 if (r->in.bind_handle == NULL) {
14644                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14645                 }
14646                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14647                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14648                 if (r->in.req == NULL) {
14649                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14650                 }
14651                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14652                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14653         }
14654         if (flags & NDR_OUT) {
14655                 if (r->out.level_out == NULL) {
14656                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14657                 }
14658                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14659                 if (r->out.ctr == NULL) {
14660                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14661                 }
14662                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14663                 NDR_CHECK(ndr_push_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14664                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14665         }
14666         return NDR_ERR_SUCCESS;
14667 }
14668
14669 static enum ndr_err_code ndr_pull_drsuapi_DsGetDomainControllerInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetDomainControllerInfo *r)
14670 {
14671         TALLOC_CTX *_mem_save_bind_handle_0;
14672         TALLOC_CTX *_mem_save_req_0;
14673         TALLOC_CTX *_mem_save_level_out_0;
14674         TALLOC_CTX *_mem_save_ctr_0;
14675         if (flags & NDR_IN) {
14676                 ZERO_STRUCT(r->out);
14677
14678                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14679                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14680                 }
14681                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14682                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14683                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14684                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14685                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14686                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14687                         NDR_PULL_ALLOC(ndr, r->in.req);
14688                 }
14689                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14690                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14691                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14692                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14693                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14694                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14695                 ZERO_STRUCTP(r->out.level_out);
14696                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14697                 ZERO_STRUCTP(r->out.ctr);
14698         }
14699         if (flags & NDR_OUT) {
14700                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14701                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14702                 }
14703                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14704                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14705                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14706                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14707                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14708                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14709                 }
14710                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14711                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14712                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14713                 NDR_CHECK(ndr_pull_drsuapi_DsGetDCInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14714                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14715                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14716         }
14717         return NDR_ERR_SUCCESS;
14718 }
14719
14720 _PUBLIC_ void ndr_print_drsuapi_DsGetDomainControllerInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetDomainControllerInfo *r)
14721 {
14722         ndr_print_struct(ndr, name, "drsuapi_DsGetDomainControllerInfo");
14723         ndr->depth++;
14724         if (flags & NDR_SET_VALUES) {
14725                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14726         }
14727         if (flags & NDR_IN) {
14728                 ndr_print_struct(ndr, "in", "drsuapi_DsGetDomainControllerInfo");
14729                 ndr->depth++;
14730                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14731                 ndr->depth++;
14732                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14733                 ndr->depth--;
14734                 ndr_print_int32(ndr, "level", r->in.level);
14735                 ndr_print_ptr(ndr, "req", r->in.req);
14736                 ndr->depth++;
14737                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14738                 ndr_print_drsuapi_DsGetDCInfoRequest(ndr, "req", r->in.req);
14739                 ndr->depth--;
14740                 ndr->depth--;
14741         }
14742         if (flags & NDR_OUT) {
14743                 ndr_print_struct(ndr, "out", "drsuapi_DsGetDomainControllerInfo");
14744                 ndr->depth++;
14745                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14746                 ndr->depth++;
14747                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14748                 ndr->depth--;
14749                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14750                 ndr->depth++;
14751                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14752                 ndr_print_drsuapi_DsGetDCInfoCtr(ndr, "ctr", r->out.ctr);
14753                 ndr->depth--;
14754                 ndr_print_WERROR(ndr, "result", r->out.result);
14755                 ndr->depth--;
14756         }
14757         ndr->depth--;
14758 }
14759
14760 _PUBLIC_ enum ndr_err_code ndr_push_drsuapi_DsAddEntry(struct ndr_push *ndr, int flags, const struct drsuapi_DsAddEntry *r)
14761 {
14762         if (flags & NDR_IN) {
14763                 if (r->in.bind_handle == NULL) {
14764                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14765                 }
14766                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14767                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
14768                 if (r->in.req == NULL) {
14769                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14770                 }
14771                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14772                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14773         }
14774         if (flags & NDR_OUT) {
14775                 if (r->out.level_out == NULL) {
14776                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14777                 }
14778                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
14779                 if (r->out.ctr == NULL) {
14780                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14781                 }
14782                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14783                 NDR_CHECK(ndr_push_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14784                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14785         }
14786         return NDR_ERR_SUCCESS;
14787 }
14788
14789 _PUBLIC_ enum ndr_err_code ndr_pull_drsuapi_DsAddEntry(struct ndr_pull *ndr, int flags, struct drsuapi_DsAddEntry *r)
14790 {
14791         TALLOC_CTX *_mem_save_bind_handle_0;
14792         TALLOC_CTX *_mem_save_req_0;
14793         TALLOC_CTX *_mem_save_level_out_0;
14794         TALLOC_CTX *_mem_save_ctr_0;
14795         if (flags & NDR_IN) {
14796                 ZERO_STRUCT(r->out);
14797
14798                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14799                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14800                 }
14801                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14802                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14803                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14804                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14805                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
14806                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14807                         NDR_PULL_ALLOC(ndr, r->in.req);
14808                 }
14809                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14810                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14811                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14812                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14813                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14814                 NDR_PULL_ALLOC(ndr, r->out.level_out);
14815                 ZERO_STRUCTP(r->out.level_out);
14816                 NDR_PULL_ALLOC(ndr, r->out.ctr);
14817                 ZERO_STRUCTP(r->out.ctr);
14818         }
14819         if (flags & NDR_OUT) {
14820                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14821                         NDR_PULL_ALLOC(ndr, r->out.level_out);
14822                 }
14823                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
14824                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
14825                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
14826                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
14827                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14828                         NDR_PULL_ALLOC(ndr, r->out.ctr);
14829                 }
14830                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
14831                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
14832                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
14833                 NDR_CHECK(ndr_pull_drsuapi_DsAddEntryCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
14834                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
14835                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14836         }
14837         return NDR_ERR_SUCCESS;
14838 }
14839
14840 _PUBLIC_ void ndr_print_drsuapi_DsAddEntry(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsAddEntry *r)
14841 {
14842         ndr_print_struct(ndr, name, "drsuapi_DsAddEntry");
14843         ndr->depth++;
14844         if (flags & NDR_SET_VALUES) {
14845                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14846         }
14847         if (flags & NDR_IN) {
14848                 ndr_print_struct(ndr, "in", "drsuapi_DsAddEntry");
14849                 ndr->depth++;
14850                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14851                 ndr->depth++;
14852                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14853                 ndr->depth--;
14854                 ndr_print_int32(ndr, "level", r->in.level);
14855                 ndr_print_ptr(ndr, "req", r->in.req);
14856                 ndr->depth++;
14857                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14858                 ndr_print_drsuapi_DsAddEntryRequest(ndr, "req", r->in.req);
14859                 ndr->depth--;
14860                 ndr->depth--;
14861         }
14862         if (flags & NDR_OUT) {
14863                 ndr_print_struct(ndr, "out", "drsuapi_DsAddEntry");
14864                 ndr->depth++;
14865                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
14866                 ndr->depth++;
14867                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
14868                 ndr->depth--;
14869                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
14870                 ndr->depth++;
14871                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
14872                 ndr_print_drsuapi_DsAddEntryCtr(ndr, "ctr", r->out.ctr);
14873                 ndr->depth--;
14874                 ndr_print_WERROR(ndr, "result", r->out.result);
14875                 ndr->depth--;
14876         }
14877         ndr->depth--;
14878 }
14879
14880 static enum ndr_err_code ndr_push_drsuapi_DsExecuteKCC(struct ndr_push *ndr, int flags, const struct drsuapi_DsExecuteKCC *r)
14881 {
14882         if (flags & NDR_IN) {
14883                 if (r->in.bind_handle == NULL) {
14884                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14885                 }
14886                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14887                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14888                 if (r->in.req == NULL) {
14889                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14890                 }
14891                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14892                 NDR_CHECK(ndr_push_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14893         }
14894         if (flags & NDR_OUT) {
14895                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14896         }
14897         return NDR_ERR_SUCCESS;
14898 }
14899
14900 static enum ndr_err_code ndr_pull_drsuapi_DsExecuteKCC(struct ndr_pull *ndr, int flags, struct drsuapi_DsExecuteKCC *r)
14901 {
14902         TALLOC_CTX *_mem_save_bind_handle_0;
14903         TALLOC_CTX *_mem_save_req_0;
14904         if (flags & NDR_IN) {
14905                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14906                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14907                 }
14908                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14909                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
14910                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14911                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
14912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14913                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14914                         NDR_PULL_ALLOC(ndr, r->in.req);
14915                 }
14916                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
14917                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
14918                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
14919                 NDR_CHECK(ndr_pull_drsuapi_DsExecuteKCCRequest(ndr, NDR_SCALARS, r->in.req));
14920                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
14921         }
14922         if (flags & NDR_OUT) {
14923                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14924         }
14925         return NDR_ERR_SUCCESS;
14926 }
14927
14928 _PUBLIC_ void ndr_print_drsuapi_DsExecuteKCC(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsExecuteKCC *r)
14929 {
14930         ndr_print_struct(ndr, name, "drsuapi_DsExecuteKCC");
14931         ndr->depth++;
14932         if (flags & NDR_SET_VALUES) {
14933                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14934         }
14935         if (flags & NDR_IN) {
14936                 ndr_print_struct(ndr, "in", "drsuapi_DsExecuteKCC");
14937                 ndr->depth++;
14938                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
14939                 ndr->depth++;
14940                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
14941                 ndr->depth--;
14942                 ndr_print_uint32(ndr, "level", r->in.level);
14943                 ndr_print_ptr(ndr, "req", r->in.req);
14944                 ndr->depth++;
14945                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
14946                 ndr_print_drsuapi_DsExecuteKCCRequest(ndr, "req", r->in.req);
14947                 ndr->depth--;
14948                 ndr->depth--;
14949         }
14950         if (flags & NDR_OUT) {
14951                 ndr_print_struct(ndr, "out", "drsuapi_DsExecuteKCC");
14952                 ndr->depth++;
14953                 ndr_print_WERROR(ndr, "result", r->out.result);
14954                 ndr->depth--;
14955         }
14956         ndr->depth--;
14957 }
14958
14959 static enum ndr_err_code ndr_push_drsuapi_DsReplicaGetInfo(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaGetInfo *r)
14960 {
14961         if (flags & NDR_IN) {
14962                 if (r->in.bind_handle == NULL) {
14963                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14964                 }
14965                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
14966                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, r->in.level));
14967                 if (r->in.req == NULL) {
14968                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14969                 }
14970                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
14971                 NDR_CHECK(ndr_push_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
14972         }
14973         if (flags & NDR_OUT) {
14974                 if (r->out.info_type == NULL) {
14975                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14976                 }
14977                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, *r->out.info_type));
14978                 if (r->out.info == NULL) {
14979                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14980                 }
14981                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.info, *r->out.info_type));
14982                 NDR_CHECK(ndr_push_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
14983                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14984         }
14985         return NDR_ERR_SUCCESS;
14986 }
14987
14988 static enum ndr_err_code ndr_pull_drsuapi_DsReplicaGetInfo(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaGetInfo *r)
14989 {
14990         TALLOC_CTX *_mem_save_bind_handle_0;
14991         TALLOC_CTX *_mem_save_req_0;
14992         TALLOC_CTX *_mem_save_info_type_0;
14993         TALLOC_CTX *_mem_save_info_0;
14994         if (flags & NDR_IN) {
14995                 ZERO_STRUCT(r->out);
14996
14997                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14998                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
14999                 }
15000                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15001                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15002                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15003                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15004                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoLevel(ndr, NDR_SCALARS, &r->in.level));
15005                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15006                         NDR_PULL_ALLOC(ndr, r->in.req);
15007                 }
15008                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15009                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15010                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15011                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaGetInfoRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15012                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15013                 NDR_PULL_ALLOC(ndr, r->out.info_type);
15014                 ZERO_STRUCTP(r->out.info_type);
15015                 NDR_PULL_ALLOC(ndr, r->out.info);
15016                 ZERO_STRUCTP(r->out.info);
15017         }
15018         if (flags & NDR_OUT) {
15019                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15020                         NDR_PULL_ALLOC(ndr, r->out.info_type);
15021                 }
15022                 _mem_save_info_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
15023                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info_type, LIBNDR_FLAG_REF_ALLOC);
15024                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfoType(ndr, NDR_SCALARS, r->out.info_type));
15025                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_type_0, LIBNDR_FLAG_REF_ALLOC);
15026                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15027                         NDR_PULL_ALLOC(ndr, r->out.info);
15028                 }
15029                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15030                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
15031                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.info, *r->out.info_type));
15032                 NDR_CHECK(ndr_pull_drsuapi_DsReplicaInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.info));
15033                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
15034                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15035         }
15036         return NDR_ERR_SUCCESS;
15037 }
15038
15039 _PUBLIC_ void ndr_print_drsuapi_DsReplicaGetInfo(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaGetInfo *r)
15040 {
15041         ndr_print_struct(ndr, name, "drsuapi_DsReplicaGetInfo");
15042         ndr->depth++;
15043         if (flags & NDR_SET_VALUES) {
15044                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15045         }
15046         if (flags & NDR_IN) {
15047                 ndr_print_struct(ndr, "in", "drsuapi_DsReplicaGetInfo");
15048                 ndr->depth++;
15049                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15050                 ndr->depth++;
15051                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15052                 ndr->depth--;
15053                 ndr_print_drsuapi_DsReplicaGetInfoLevel(ndr, "level", r->in.level);
15054                 ndr_print_ptr(ndr, "req", r->in.req);
15055                 ndr->depth++;
15056                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15057                 ndr_print_drsuapi_DsReplicaGetInfoRequest(ndr, "req", r->in.req);
15058                 ndr->depth--;
15059                 ndr->depth--;
15060         }
15061         if (flags & NDR_OUT) {
15062                 ndr_print_struct(ndr, "out", "drsuapi_DsReplicaGetInfo");
15063                 ndr->depth++;
15064                 ndr_print_ptr(ndr, "info_type", r->out.info_type);
15065                 ndr->depth++;
15066                 ndr_print_drsuapi_DsReplicaInfoType(ndr, "info_type", *r->out.info_type);
15067                 ndr->depth--;
15068                 ndr_print_ptr(ndr, "info", r->out.info);
15069                 ndr->depth++;
15070                 ndr_print_set_switch_value(ndr, r->out.info, *r->out.info_type);
15071                 ndr_print_drsuapi_DsReplicaInfo(ndr, "info", r->out.info);
15072                 ndr->depth--;
15073                 ndr_print_WERROR(ndr, "result", r->out.result);
15074                 ndr->depth--;
15075         }
15076         ndr->depth--;
15077 }
15078
15079 static enum ndr_err_code ndr_push_DRSUAPI_ADD_SID_HISTORY(struct ndr_push *ndr, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15080 {
15081         if (flags & NDR_IN) {
15082         }
15083         if (flags & NDR_OUT) {
15084                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15085         }
15086         return NDR_ERR_SUCCESS;
15087 }
15088
15089 static enum ndr_err_code ndr_pull_DRSUAPI_ADD_SID_HISTORY(struct ndr_pull *ndr, int flags, struct DRSUAPI_ADD_SID_HISTORY *r)
15090 {
15091         if (flags & NDR_IN) {
15092         }
15093         if (flags & NDR_OUT) {
15094                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15095         }
15096         return NDR_ERR_SUCCESS;
15097 }
15098
15099 _PUBLIC_ void ndr_print_DRSUAPI_ADD_SID_HISTORY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_ADD_SID_HISTORY *r)
15100 {
15101         ndr_print_struct(ndr, name, "DRSUAPI_ADD_SID_HISTORY");
15102         ndr->depth++;
15103         if (flags & NDR_SET_VALUES) {
15104                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15105         }
15106         if (flags & NDR_IN) {
15107                 ndr_print_struct(ndr, "in", "DRSUAPI_ADD_SID_HISTORY");
15108                 ndr->depth++;
15109                 ndr->depth--;
15110         }
15111         if (flags & NDR_OUT) {
15112                 ndr_print_struct(ndr, "out", "DRSUAPI_ADD_SID_HISTORY");
15113                 ndr->depth++;
15114                 ndr_print_WERROR(ndr, "result", r->out.result);
15115                 ndr->depth--;
15116         }
15117         ndr->depth--;
15118 }
15119
15120 static enum ndr_err_code ndr_push_drsuapi_DsGetMemberships2(struct ndr_push *ndr, int flags, const struct drsuapi_DsGetMemberships2 *r)
15121 {
15122         if (flags & NDR_IN) {
15123                 if (r->in.bind_handle == NULL) {
15124                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15125                 }
15126                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15127                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15128                 if (r->in.req == NULL) {
15129                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15130                 }
15131                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15132                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15133         }
15134         if (flags & NDR_OUT) {
15135                 if (r->out.level_out == NULL) {
15136                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15137                 }
15138                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15139                 if (r->out.ctr == NULL) {
15140                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15141                 }
15142                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15143                 NDR_CHECK(ndr_push_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15144                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15145         }
15146         return NDR_ERR_SUCCESS;
15147 }
15148
15149 static enum ndr_err_code ndr_pull_drsuapi_DsGetMemberships2(struct ndr_pull *ndr, int flags, struct drsuapi_DsGetMemberships2 *r)
15150 {
15151         TALLOC_CTX *_mem_save_bind_handle_0;
15152         TALLOC_CTX *_mem_save_req_0;
15153         TALLOC_CTX *_mem_save_level_out_0;
15154         TALLOC_CTX *_mem_save_ctr_0;
15155         if (flags & NDR_IN) {
15156                 ZERO_STRUCT(r->out);
15157
15158                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15159                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15160                 }
15161                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15162                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15163                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15164                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15165                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15166                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15167                         NDR_PULL_ALLOC(ndr, r->in.req);
15168                 }
15169                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15170                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15171                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15172                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Request(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15173                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15174                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15175                 ZERO_STRUCTP(r->out.level_out);
15176                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15177                 ZERO_STRUCTP(r->out.ctr);
15178         }
15179         if (flags & NDR_OUT) {
15180                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15181                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15182                 }
15183                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15184                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15185                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15186                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15187                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15188                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15189                 }
15190                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15191                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15192                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15193                 NDR_CHECK(ndr_pull_drsuapi_DsGetMemberships2Ctr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15194                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15195                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15196         }
15197         return NDR_ERR_SUCCESS;
15198 }
15199
15200 _PUBLIC_ void ndr_print_drsuapi_DsGetMemberships2(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships2 *r)
15201 {
15202         ndr_print_struct(ndr, name, "drsuapi_DsGetMemberships2");
15203         ndr->depth++;
15204         if (flags & NDR_SET_VALUES) {
15205                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15206         }
15207         if (flags & NDR_IN) {
15208                 ndr_print_struct(ndr, "in", "drsuapi_DsGetMemberships2");
15209                 ndr->depth++;
15210                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15211                 ndr->depth++;
15212                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15213                 ndr->depth--;
15214                 ndr_print_int32(ndr, "level", r->in.level);
15215                 ndr_print_ptr(ndr, "req", r->in.req);
15216                 ndr->depth++;
15217                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15218                 ndr_print_drsuapi_DsGetMemberships2Request(ndr, "req", r->in.req);
15219                 ndr->depth--;
15220                 ndr->depth--;
15221         }
15222         if (flags & NDR_OUT) {
15223                 ndr_print_struct(ndr, "out", "drsuapi_DsGetMemberships2");
15224                 ndr->depth++;
15225                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15226                 ndr->depth++;
15227                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15228                 ndr->depth--;
15229                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15230                 ndr->depth++;
15231                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15232                 ndr_print_drsuapi_DsGetMemberships2Ctr(ndr, "ctr", r->out.ctr);
15233                 ndr->depth--;
15234                 ndr_print_WERROR(ndr, "result", r->out.result);
15235                 ndr->depth--;
15236         }
15237         ndr->depth--;
15238 }
15239
15240 static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15241 {
15242         if (flags & NDR_IN) {
15243         }
15244         if (flags & NDR_OUT) {
15245                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15246         }
15247         return NDR_ERR_SUCCESS;
15248 }
15249
15250 static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15251 {
15252         if (flags & NDR_IN) {
15253         }
15254         if (flags & NDR_OUT) {
15255                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15256         }
15257         return NDR_ERR_SUCCESS;
15258 }
15259
15260 _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
15261 {
15262         ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15263         ndr->depth++;
15264         if (flags & NDR_SET_VALUES) {
15265                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15266         }
15267         if (flags & NDR_IN) {
15268                 ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15269                 ndr->depth++;
15270                 ndr->depth--;
15271         }
15272         if (flags & NDR_OUT) {
15273                 ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_VERIFY_OBJECTS");
15274                 ndr->depth++;
15275                 ndr_print_WERROR(ndr, "result", r->out.result);
15276                 ndr->depth--;
15277         }
15278         ndr->depth--;
15279 }
15280
15281 static enum ndr_err_code ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_push *ndr, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15282 {
15283         if (flags & NDR_IN) {
15284         }
15285         if (flags & NDR_OUT) {
15286                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15287         }
15288         return NDR_ERR_SUCCESS;
15289 }
15290
15291 static enum ndr_err_code ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_pull *ndr, int flags, struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15292 {
15293         if (flags & NDR_IN) {
15294         }
15295         if (flags & NDR_OUT) {
15296                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15297         }
15298         return NDR_ERR_SUCCESS;
15299 }
15300
15301 _PUBLIC_ void ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
15302 {
15303         ndr_print_struct(ndr, name, "DRSUAPI_GET_OBJECT_EXISTENCE");
15304         ndr->depth++;
15305         if (flags & NDR_SET_VALUES) {
15306                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15307         }
15308         if (flags & NDR_IN) {
15309                 ndr_print_struct(ndr, "in", "DRSUAPI_GET_OBJECT_EXISTENCE");
15310                 ndr->depth++;
15311                 ndr->depth--;
15312         }
15313         if (flags & NDR_OUT) {
15314                 ndr_print_struct(ndr, "out", "DRSUAPI_GET_OBJECT_EXISTENCE");
15315                 ndr->depth++;
15316                 ndr_print_WERROR(ndr, "result", r->out.result);
15317                 ndr->depth--;
15318         }
15319         ndr->depth--;
15320 }
15321
15322 static enum ndr_err_code ndr_push_drsuapi_QuerySitesByCost(struct ndr_push *ndr, int flags, const struct drsuapi_QuerySitesByCost *r)
15323 {
15324         if (flags & NDR_IN) {
15325                 if (r->in.bind_handle == NULL) {
15326                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15327                 }
15328                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15329                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level));
15330                 if (r->in.req == NULL) {
15331                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15332                 }
15333                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.req, r->in.level));
15334                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15335         }
15336         if (flags & NDR_OUT) {
15337                 if (r->out.level_out == NULL) {
15338                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15339                 }
15340                 NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, *r->out.level_out));
15341                 if (r->out.ctr == NULL) {
15342                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15343                 }
15344                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15345                 NDR_CHECK(ndr_push_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15346                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15347         }
15348         return NDR_ERR_SUCCESS;
15349 }
15350
15351 static enum ndr_err_code ndr_pull_drsuapi_QuerySitesByCost(struct ndr_pull *ndr, int flags, struct drsuapi_QuerySitesByCost *r)
15352 {
15353         TALLOC_CTX *_mem_save_bind_handle_0;
15354         TALLOC_CTX *_mem_save_req_0;
15355         TALLOC_CTX *_mem_save_level_out_0;
15356         TALLOC_CTX *_mem_save_ctr_0;
15357         if (flags & NDR_IN) {
15358                 ZERO_STRUCT(r->out);
15359
15360                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15361                         NDR_PULL_ALLOC(ndr, r->in.bind_handle);
15362                 }
15363                 _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15364                 NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC);
15365                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle));
15366                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC);
15367                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level));
15368                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15369                         NDR_PULL_ALLOC(ndr, r->in.req);
15370                 }
15371                 _mem_save_req_0 = NDR_PULL_GET_MEM_CTX(ndr);
15372                 NDR_PULL_SET_MEM_CTX(ndr, r->in.req, LIBNDR_FLAG_REF_ALLOC);
15373                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.req, r->in.level));
15374                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostRequest(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.req));
15375                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_req_0, LIBNDR_FLAG_REF_ALLOC);
15376                 NDR_PULL_ALLOC(ndr, r->out.level_out);
15377                 ZERO_STRUCTP(r->out.level_out);
15378                 NDR_PULL_ALLOC(ndr, r->out.ctr);
15379                 ZERO_STRUCTP(r->out.ctr);
15380         }
15381         if (flags & NDR_OUT) {
15382                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15383                         NDR_PULL_ALLOC(ndr, r->out.level_out);
15384                 }
15385                 _mem_save_level_out_0 = NDR_PULL_GET_MEM_CTX(ndr);
15386                 NDR_PULL_SET_MEM_CTX(ndr, r->out.level_out, LIBNDR_FLAG_REF_ALLOC);
15387                 NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, r->out.level_out));
15388                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level_out_0, LIBNDR_FLAG_REF_ALLOC);
15389                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15390                         NDR_PULL_ALLOC(ndr, r->out.ctr);
15391                 }
15392                 _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
15393                 NDR_PULL_SET_MEM_CTX(ndr, r->out.ctr, LIBNDR_FLAG_REF_ALLOC);
15394                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.ctr, *r->out.level_out));
15395                 NDR_CHECK(ndr_pull_drsuapi_QuerySitesByCostCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.ctr));
15396                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, LIBNDR_FLAG_REF_ALLOC);
15397                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15398         }
15399         return NDR_ERR_SUCCESS;
15400 }
15401
15402 _PUBLIC_ void ndr_print_drsuapi_QuerySitesByCost(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_QuerySitesByCost *r)
15403 {
15404         ndr_print_struct(ndr, name, "drsuapi_QuerySitesByCost");
15405         ndr->depth++;
15406         if (flags & NDR_SET_VALUES) {
15407                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15408         }
15409         if (flags & NDR_IN) {
15410                 ndr_print_struct(ndr, "in", "drsuapi_QuerySitesByCost");
15411                 ndr->depth++;
15412                 ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle);
15413                 ndr->depth++;
15414                 ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle);
15415                 ndr->depth--;
15416                 ndr_print_int32(ndr, "level", r->in.level);
15417                 ndr_print_ptr(ndr, "req", r->in.req);
15418                 ndr->depth++;
15419                 ndr_print_set_switch_value(ndr, r->in.req, r->in.level);
15420                 ndr_print_drsuapi_QuerySitesByCostRequest(ndr, "req", r->in.req);
15421                 ndr->depth--;
15422                 ndr->depth--;
15423         }
15424         if (flags & NDR_OUT) {
15425                 ndr_print_struct(ndr, "out", "drsuapi_QuerySitesByCost");
15426                 ndr->depth++;
15427                 ndr_print_ptr(ndr, "level_out", r->out.level_out);
15428                 ndr->depth++;
15429                 ndr_print_int32(ndr, "level_out", *r->out.level_out);
15430                 ndr->depth--;
15431                 ndr_print_ptr(ndr, "ctr", r->out.ctr);
15432                 ndr->depth++;
15433                 ndr_print_set_switch_value(ndr, r->out.ctr, *r->out.level_out);
15434                 ndr_print_drsuapi_QuerySitesByCostCtr(ndr, "ctr", r->out.ctr);
15435                 ndr->depth--;
15436                 ndr_print_WERROR(ndr, "result", r->out.result);
15437                 ndr->depth--;
15438         }
15439         ndr->depth--;
15440 }
15441
15442 static const struct ndr_interface_call drsuapi_calls[] = {
15443         {
15444                 "drsuapi_DsBind",
15445                 sizeof(struct drsuapi_DsBind),
15446                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsBind,
15447                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsBind,
15448                 (ndr_print_function_t) ndr_print_drsuapi_DsBind,
15449                 false,
15450         },
15451         {
15452                 "drsuapi_DsUnbind",
15453                 sizeof(struct drsuapi_DsUnbind),
15454                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsUnbind,
15455                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsUnbind,
15456                 (ndr_print_function_t) ndr_print_drsuapi_DsUnbind,
15457                 false,
15458         },
15459         {
15460                 "drsuapi_DsReplicaSync",
15461                 sizeof(struct drsuapi_DsReplicaSync),
15462                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaSync,
15463                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaSync,
15464                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaSync,
15465                 false,
15466         },
15467         {
15468                 "drsuapi_DsGetNCChanges",
15469                 sizeof(struct drsuapi_DsGetNCChanges),
15470                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNCChanges,
15471                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNCChanges,
15472                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNCChanges,
15473                 false,
15474         },
15475         {
15476                 "drsuapi_DsReplicaUpdateRefs",
15477                 sizeof(struct drsuapi_DsReplicaUpdateRefs),
15478                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaUpdateRefs,
15479                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaUpdateRefs,
15480                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaUpdateRefs,
15481                 false,
15482         },
15483         {
15484                 "drsuapi_DsReplicaAdd",
15485                 sizeof(struct drsuapi_DsReplicaAdd),
15486                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaAdd,
15487                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaAdd,
15488                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaAdd,
15489                 false,
15490         },
15491         {
15492                 "drsuapi_DsReplicaDel",
15493                 sizeof(struct drsuapi_DsReplicaDel),
15494                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaDel,
15495                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaDel,
15496                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaDel,
15497                 false,
15498         },
15499         {
15500                 "drsuapi_DsReplicaMod",
15501                 sizeof(struct drsuapi_DsReplicaMod),
15502                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaMod,
15503                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaMod,
15504                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaMod,
15505                 false,
15506         },
15507         {
15508                 "DRSUAPI_VERIFY_NAMES",
15509                 sizeof(struct DRSUAPI_VERIFY_NAMES),
15510                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_VERIFY_NAMES,
15511                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_VERIFY_NAMES,
15512                 (ndr_print_function_t) ndr_print_DRSUAPI_VERIFY_NAMES,
15513                 false,
15514         },
15515         {
15516                 "drsuapi_DsGetMemberships",
15517                 sizeof(struct drsuapi_DsGetMemberships),
15518                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships,
15519                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships,
15520                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships,
15521                 false,
15522         },
15523         {
15524                 "DRSUAPI_INTER_DOMAIN_MOVE",
15525                 sizeof(struct DRSUAPI_INTER_DOMAIN_MOVE),
15526                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_INTER_DOMAIN_MOVE,
15527                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_INTER_DOMAIN_MOVE,
15528                 (ndr_print_function_t) ndr_print_DRSUAPI_INTER_DOMAIN_MOVE,
15529                 false,
15530         },
15531         {
15532                 "drsuapi_DsGetNT4ChangeLog",
15533                 sizeof(struct drsuapi_DsGetNT4ChangeLog),
15534                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetNT4ChangeLog,
15535                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetNT4ChangeLog,
15536                 (ndr_print_function_t) ndr_print_drsuapi_DsGetNT4ChangeLog,
15537                 false,
15538         },
15539         {
15540                 "drsuapi_DsCrackNames",
15541                 sizeof(struct drsuapi_DsCrackNames),
15542                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsCrackNames,
15543                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsCrackNames,
15544                 (ndr_print_function_t) ndr_print_drsuapi_DsCrackNames,
15545                 false,
15546         },
15547         {
15548                 "drsuapi_DsWriteAccountSpn",
15549                 sizeof(struct drsuapi_DsWriteAccountSpn),
15550                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsWriteAccountSpn,
15551                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsWriteAccountSpn,
15552                 (ndr_print_function_t) ndr_print_drsuapi_DsWriteAccountSpn,
15553                 false,
15554         },
15555         {
15556                 "drsuapi_DsRemoveDSServer",
15557                 sizeof(struct drsuapi_DsRemoveDSServer),
15558                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsRemoveDSServer,
15559                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsRemoveDSServer,
15560                 (ndr_print_function_t) ndr_print_drsuapi_DsRemoveDSServer,
15561                 false,
15562         },
15563         {
15564                 "DRSUAPI_REMOVE_DS_DOMAIN",
15565                 sizeof(struct DRSUAPI_REMOVE_DS_DOMAIN),
15566                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REMOVE_DS_DOMAIN,
15567                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REMOVE_DS_DOMAIN,
15568                 (ndr_print_function_t) ndr_print_DRSUAPI_REMOVE_DS_DOMAIN,
15569                 false,
15570         },
15571         {
15572                 "drsuapi_DsGetDomainControllerInfo",
15573                 sizeof(struct drsuapi_DsGetDomainControllerInfo),
15574                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetDomainControllerInfo,
15575                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetDomainControllerInfo,
15576                 (ndr_print_function_t) ndr_print_drsuapi_DsGetDomainControllerInfo,
15577                 false,
15578         },
15579         {
15580                 "drsuapi_DsAddEntry",
15581                 sizeof(struct drsuapi_DsAddEntry),
15582                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsAddEntry,
15583                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsAddEntry,
15584                 (ndr_print_function_t) ndr_print_drsuapi_DsAddEntry,
15585                 false,
15586         },
15587         {
15588                 "drsuapi_DsExecuteKCC",
15589                 sizeof(struct drsuapi_DsExecuteKCC),
15590                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsExecuteKCC,
15591                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsExecuteKCC,
15592                 (ndr_print_function_t) ndr_print_drsuapi_DsExecuteKCC,
15593                 false,
15594         },
15595         {
15596                 "drsuapi_DsReplicaGetInfo",
15597                 sizeof(struct drsuapi_DsReplicaGetInfo),
15598                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaGetInfo,
15599                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaGetInfo,
15600                 (ndr_print_function_t) ndr_print_drsuapi_DsReplicaGetInfo,
15601                 false,
15602         },
15603         {
15604                 "DRSUAPI_ADD_SID_HISTORY",
15605                 sizeof(struct DRSUAPI_ADD_SID_HISTORY),
15606                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_ADD_SID_HISTORY,
15607                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_ADD_SID_HISTORY,
15608                 (ndr_print_function_t) ndr_print_DRSUAPI_ADD_SID_HISTORY,
15609                 false,
15610         },
15611         {
15612                 "drsuapi_DsGetMemberships2",
15613                 sizeof(struct drsuapi_DsGetMemberships2),
15614                 (ndr_push_flags_fn_t) ndr_push_drsuapi_DsGetMemberships2,
15615                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsGetMemberships2,
15616                 (ndr_print_function_t) ndr_print_drsuapi_DsGetMemberships2,
15617                 false,
15618         },
15619         {
15620                 "DRSUAPI_REPLICA_VERIFY_OBJECTS",
15621                 sizeof(struct DRSUAPI_REPLICA_VERIFY_OBJECTS),
15622                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15623                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15624                 (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_VERIFY_OBJECTS,
15625                 false,
15626         },
15627         {
15628                 "DRSUAPI_GET_OBJECT_EXISTENCE",
15629                 sizeof(struct DRSUAPI_GET_OBJECT_EXISTENCE),
15630                 (ndr_push_flags_fn_t) ndr_push_DRSUAPI_GET_OBJECT_EXISTENCE,
15631                 (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_GET_OBJECT_EXISTENCE,
15632                 (ndr_print_function_t) ndr_print_DRSUAPI_GET_OBJECT_EXISTENCE,
15633                 false,
15634         },
15635         {
15636                 "drsuapi_QuerySitesByCost",
15637                 sizeof(struct drsuapi_QuerySitesByCost),
15638                 (ndr_push_flags_fn_t) ndr_push_drsuapi_QuerySitesByCost,
15639                 (ndr_pull_flags_fn_t) ndr_pull_drsuapi_QuerySitesByCost,
15640                 (ndr_print_function_t) ndr_print_drsuapi_QuerySitesByCost,
15641                 false,
15642         },
15643         { NULL, 0, NULL, NULL, NULL, false }
15644 };
15645
15646 static const char * const drsuapi_endpoint_strings[] = {
15647         "ncacn_np:[\\pipe\\lsass]",
15648         "ncacn_np:[\\pipe\\protected_storage]",
15649         "ncacn_ip_tcp:",
15650         "ncalrpc:",
15651 };
15652
15653 static const struct ndr_interface_string_array drsuapi_endpoints = {
15654         .count  = 4,
15655         .names  = drsuapi_endpoint_strings
15656 };
15657
15658 static const char * const drsuapi_authservice_strings[] = {
15659         "ldap",
15660 };
15661
15662 static const struct ndr_interface_string_array drsuapi_authservices = {
15663         .count  = 1,
15664         .names  = drsuapi_authservice_strings
15665 };
15666
15667
15668 const struct ndr_interface_table ndr_table_drsuapi = {
15669         .name           = "drsuapi",
15670         .syntax_id      = {
15671                 {0xe3514235,0x4b06,0x11d1,{0xab,0x04},{0x00,0xc0,0x4f,0xc2,0xdc,0xd2}},
15672                 NDR_DRSUAPI_VERSION
15673         },
15674         .helpstring     = NDR_DRSUAPI_HELPSTRING,
15675         .num_calls      = 25,
15676         .calls          = drsuapi_calls,
15677         .endpoints      = &drsuapi_endpoints,
15678         .authservices   = &drsuapi_authservices
15679 };
15680